Micron Document
<!DOCTYPE html>
<html class="client-nojs vector-feature-language-in-header-enabled vector-feature-language-in-main-page-header-disabled vector-feature-page-tools-pinned-disabled vector-feature-toc-pinned-clientpref-0 vector-toc-not-available vector-feature-main-menu-pinned-disabled vector-feature-limited-width-clientpref-1 vector-feature-limited-width-content-enabled vector-feature-custom-font-size-clientpref-1 vector-feature-appearance-pinned-clientpref-0 vector-feature-night-mode-enabled skin-theme-clientpref-os vector-sticky-header-enabled" lang="fr" dir="ltr"><head>
<meta charset="UTF-8">
<title>C++</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" type="image/png" href="./_res_/favicon.png">
<link rel="canonical" href="https://fr.wikipedia.org/wiki/C%2B%2B"> <link href="./_mw_/ext.cite.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.pygments.css" rel="stylesheet" type="text/css">
<link href="./_mw_/ext.wikimediamessages.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.icons.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.search.codex.styles.css" rel="stylesheet" type="text/css">
<link href="./_mw_/skins.vector.styles.css" rel="stylesheet" type="text/css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" type="text/css" href="./_mw_/site.styles.css">
<link rel="stylesheet" type="text/css" href="./_mw_/noscript.css">
<link rel="stylesheet" type="text/css" href="./_res_/footer.css">
<link rel="stylesheet" type="text/css" href="./_res_/vector-2022.css">
</head>
<body class="skin--responsive skin-vector skin-vector-search-vue mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-C rootpage-C skin-vector-2022 action-view">
<div class="mw-page-container">
<div class="mw-page-container-inner">
<div class="mw-content-container">
<main id="content" class="mw-body">
<header class="mw-body-header vector-page-titlebar">
<h1 id="firstHeading" class="firstHeading mw-first-heading"><span class="mw-page-title-main">C++</span></h1>
</header>
<a id="top"></a>
<div id="bodyContent" class="vector-body ve-init-mw-desktopArticleTarget-targetContainer" aria-labelledby="firstHeading" data-mw-ve-target-container="">
<div id="contentSub">
<div id="mw-content-subtitle"></div>
</div>
<div id="mw-content-text" class="mw-body-content mw-content-ltr" lang="fr" dir="ltr"><div class="mw-content-ltr mw-parser-output" lang="fr" dir="ltr"><p class="mw-empty-elt">
</p>
<table class="infobox_v2 infobox infobox--frwiki noarchive">
<tbody><tr>
<td colspan="2" class="entete informatique" style="background-color:#659bd3;color:black;"><span style="color: #fff;">C++</span><style data-mw-deduplicate="TemplateStyles:r228712691">
/* start https://fr.wikipedia.org/ */


.mw-parser-output .entete.informatique{background-image:url("./_mw_/Picto.nfo.png")}


/* end https://fr.wikipedia.org/ */
</style>
</td></tr>
<tr><td colspan="3" style="text-align:center; line-height: 1.5em;"> </td></tr>
<tr>
<td colspan="3" style="text-align:center; line-height: 1.5em;"> <br>Code en C++ pour afficher <i>Hello, World&nbsp;!</i></td></tr>
<tr>
<td colspan="2"><hr style="height:2px; color:inherit; background-color:#659bd3;"></td></tr>
<tr>
<th scope="row">Date de première version
</th>
<td><a href="1985" title="1985">1985</a><sup id="cite_ref-1" class="reference"><a href="#cite_note-1"><span class="cite-bracket">[</span>1<span class="cite-bracket">]</span></a></sup>
</td>
</tr>
<tr>
<th scope="row"><a href="Paradigme_(programmation)" title="Paradigme (programmation)">Paradigme</a>
</th>
<td><a href="G%C3%A9n%C3%A9ricit%C3%A9" title="Généricité">générique</a>, <a href="Programmation_orient%C3%A9e_objet" title="Programmation orientée objet">orienté objet</a>, <a href="Programmation_proc%C3%A9durale" title="Programmation procédurale">procédural</a>
</td>
</tr>
<tr>

<th scope="row">Auteur
</th>
<td><a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a>
</td>
</tr>
<tr>



<th scope="row"><a href="Version_d'un_logiciel" title="Version d'un logiciel">Dernière version</a>
</th>
<td><span class="wd_p348">C++23 (<time class="nowrap date-lien" datetime="2024-10-19" data-sort-value="2024-10-19"><a href="19_octobre" title="19 octobre">19</a> <a href="Octobre_2024" title="Octobre 2024">octobre</a> <a href="2024" title="2024">2024</a></time>)<sup id="cite_ref-wikidata-1cb32e45d32ea7da85b87c5f5ef5b8c3cba362e8_2-1" class="reference"><a href="#cite_note-wikidata-1cb32e45d32ea7da85b87c5f5ef5b8c3cba362e8-2"><span class="cite-bracket">[</span>2<span class="cite-bracket">]</span></a></sup></span>
</td>
</tr>
<tr>

<th scope="row">Typage
</th>
<td><a href="Typage_statique" title="Typage statique">statique</a>, <a href="S%C3%BBret%C3%A9_du_typage" title="Sûreté du typage">unsafe</a>, <a href="Syst%C3%A8me_nominatif_de_types" title="Système nominatif de types">nominatif</a>
</td>
</tr>
<tr>
<th scope="row"><a href="Norme" title="Norme">Normes</a>
</th>
<td>ISO/CEI 14882:1998<br>ISO/CEI 14882:2003<br>ISO/CEI 14882:2011<br>ISO/CEI 14882:2014<br>ISO/CEI 14882:2017<br>ISO/IEC 14882:2020<br>ISO/IEC 14882:2024
</td>
</tr>
<tr>

<th scope="row">Influencé par
</th>
<td><a href="C_(langage)" title="C (langage)">C</a>, <a href="Simula" title="Simula">Simula</a>, <a href="Ada_(langage)" title="Ada (langage)">Ada 83</a>, <a href="Algol_68" title="Algol 68">Algol 68</a>, <a href="CLU_(langage)" title="CLU (langage)">CLU</a>, <a href="ML_(langage)" title="ML (langage)">ML</a>
</td>
</tr>
<tr>
<th scope="row">A influencé
</th>
<td><a href="Ada_(langage)" title="Ada (langage)">Ada 95</a>, <a href="C_sharp" class="mw-redirect" title="C sharp">C#</a>, <a href="PHP" title="PHP">PHP</a>, <a href="D_(langage)" title="D (langage)">D</a>, <a href="JavaScript" title="JavaScript">JavaScript</a>, <a href="Java_(langage)" title="Java (langage)">Java</a>, <a href="X%2B%2B" title="X++">X++</a>, <a href="Rust_(langage)" title="Rust (langage)">Rust</a>
</td>
</tr>
<tr>
<th scope="row">Implémentations
</th>
<td><a href="GNU_Compiler_Collection" title="GNU Compiler Collection">GNU Compiler Collection</a>, <a href="Clang" title="Clang">LLVM Clang++</a>, <a href="Visual_C%2B%2B" title="Visual C++">Microsoft Visual C++</a>, <a href="C%2B%2BBuilder" title="C++Builder">Embarcadero C++ Builder</a>
</td>
</tr>
<tr>




<th scope="row"><a href="Site_web" title="Site web">Site web</a>
</th>
<td><span class="wd_p856"><a rel="nofollow" class="external text" href="https://isocpp.org/">isocpp.org</a></span>
</td>
</tr>
<tr>
<th scope="row"><a href="Extension_de_nom_de_fichier" title="Extension de nom de fichier">Extension de fichier</a>
</th>
<td><span class="wd_p1195">cc, cpp, cxx, c, c++, h, hpp, hh, hxx et h++</span>
</td>
</tr>
<tr>

</tr>
</tbody></table>
<p><b>C++</b> est un <a href="Langage_de_programmation" title="Langage de programmation">langage de programmation</a> <a href="Compilateur" title="Compilateur">compilé</a> permettant la programmation sous de multiples <a href="Paradigme_(programmation)" title="Paradigme (programmation)">paradigmes</a>, dont la <a href="Programmation_proc%C3%A9durale" title="Programmation procédurale">programmation procédurale</a>, la <a href="Programmation_orient%C3%A9e_objet" title="Programmation orientée objet">programmation orientée objet</a> et la <a href="Programmation_g%C3%A9n%C3%A9rique" class="mw-redirect" title="Programmation générique">programmation générique</a>. Ses bonnes <a href="Performances_(informatique)" title="Performances (informatique)">performances</a>, et sa compatibilité avec le langage <a href="C_(langage)" title="C (langage)">C</a> en font un des langages de programmation les plus utilisés dans les applications où la performance est critique.
</p><p>Créé initialement par <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a> dans les années 1980, le langage C++ est aujourd'hui <a href="Norme_industrielle" class="mw-redirect" title="Norme industrielle">normalisé</a> par l'<a href="Organisation_internationale_de_normalisation" title="Organisation internationale de normalisation">ISO</a>. Sa première normalisation date de <a href="1998" title="1998">1998</a> (ISO/CEI 14882:1998), ensuite amendée par l'erratum technique de <a href="2003" title="2003">2003</a> (ISO/CEI 14882:2003). Une importante mise à jour a été ratifiée et publiée par l'ISO en <time class="nowrap" datetime="2011-09" data-sort-value="2011-09">septembre 2011</time> sous le nom de ISO/IEC 14882:2011, ou <a href="C%2B%2B11" title="C++11">C++11</a><sup id="cite_ref-3" class="reference"><a href="#cite_note-3"><span class="cite-bracket">[</span>3<span class="cite-bracket">]</span></a></sup>. Depuis, des mises à jour sont publiées régulièrement&nbsp;: en <time>2014</time> (ISO/CEI 14882:2014, ou <a href="C%2B%2B14" title="C++14">C++14</a><sup id="cite_ref-4" class="reference"><a href="#cite_note-4"><span class="cite-bracket">[</span>4<span class="cite-bracket">]</span></a></sup>), en <time>2017</time> (ISO/CEI 14882:2017, ou <a href="C%2B%2B17" title="C++17">C++17</a><sup id="cite_ref-5" class="reference"><a href="#cite_note-5"><span class="cite-bracket">[</span>5<span class="cite-bracket">]</span></a></sup>) puis en <time>2020</time> (ISO/IEC 14882:2020, ou <a href="C%2B%2B20" title="C++20">C++20</a><sup id="cite_ref-6" class="reference"><a href="#cite_note-6"><span class="cite-bracket">[</span>6<span class="cite-bracket">]</span></a></sup>) et en <time>2023</time> (<a href="C%2B%2B23" title="C++23">C++23</a>).
</p>

<div class="mw-heading mw-heading2"><h2 id="Dénomination"><span id="D.C3.A9nomination"></span>Dénomination</h2></div>
<p>En <a href="C_(langage)" title="C (langage)">langage C</a>, <code>++</code> est l'opérateur d'incrémentation, c'est-à-dire l'augmentation de la valeur d'une variable de 1. C'est pourquoi C++ porte ce nom&nbsp;: cela signifie que C++ est un niveau au-dessus de C<sup id="cite_ref-7" class="reference"><a href="#cite_note-7"><span class="cite-bracket">[</span>7<span class="cite-bracket">]</span></a></sup>.
</p>
<div class="mw-heading mw-heading2"><h2 id="Histoire">Histoire</h2></div>

<p><a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a> commence le développement de <i>C with Classes</i> (C avec <a href="Classe_(informatique)" title="Classe (informatique)">classes</a>) en <a href="1979" title="1979">1979</a><sup id="cite_ref-8" class="reference"><a href="#cite_note-8"><span class="cite-bracket">[</span>8<span class="cite-bracket">]</span></a></sup>. Il travaille alors dans les <a href="Laboratoires_Bell" title="Laboratoires Bell">laboratoires Bell</a> où il est notamment collègue de l'inventeur du C <a href="Dennis_Ritchie" title="Dennis Ritchie">Dennis Ritchie</a>. L'idée de créer un nouveau langage venait de l'expérience en programmation de Stroustrup pour sa thèse de doctorat. Il s'agissait en l'occurrence d'améliorer le <a href="Langage_C" class="mw-redirect" title="Langage C">langage C</a>. Stroustrup trouvait que <a href="Simula" title="Simula">Simula</a> avait des fonctionnalités très utiles pour le développement de gros programmes mais qu'il était trop lent pour être utilisé en pratique (cela était dû à un problème d'<a href="Mise_en_%C5%93uvre" title="Mise en œuvre">implémentation</a> du compilateur <a href="Simula" title="Simula">Simula</a>), tandis que <a href="BCPL" title="BCPL">BCPL</a> était rapide mais de trop <a href="Langage_de_programmation_de_bas_niveau" title="Langage de programmation de bas niveau">bas niveau</a> et non adapté au développement de gros logiciels. Quand Stroustrup commença à travailler aux <a href="Laboratoires_Bell" title="Laboratoires Bell">laboratoires Bell</a>, on lui demanda d'analyser le <a href="Noyau_(informatique)" class="mw-redirect" title="Noyau (informatique)">noyau</a> <a href="UNIX" class="mw-redirect" title="UNIX">UNIX</a> en vue de faire du <a href="Calcul_distribu%C3%A9" title="Calcul distribué">calcul distribué</a>. Se rappelant sa thèse, Stroustrup commença à améliorer le langage <a href="C_(langage)" title="C (langage)">C</a> avec des fonctionnalités similaires à celle de <a href="Simula" title="Simula">Simula</a>. C fut choisi parce qu'il est rapide, <a href="Portabilit%C3%A9_(informatique)" title="Portabilité (informatique)">portable</a> et d'usage général. En outre, il était une bonne base pour le principe original et fondateur de C++&nbsp;: «&nbsp;vous ne payez pas pour ce que vous n'utilisez pas&nbsp;». Dès le départ, le langage ajoutait à C la notion de classe (avec <a href="Encapsulation_(programmation)" title="Encapsulation (programmation)">encapsulation des données</a>), de classe dérivée, de vérification des types renforcés (<a href="Typage_fort" title="Typage fort">typage fort</a>), d'«&nbsp;<a href="Extension_inline" title="Extension inline">inlining</a>&nbsp;», et de <a href="Param%C3%A8tre_(programmation_informatique)" title="Paramètre (programmation informatique)">paramètre</a> par défaut.
</p><p>Alors que Stroustrup développait <i>C with classes</i>, il écrivit CFront, un compilateur qui générait du code source C à partir de code source <i>C with classes</i>. La première commercialisation se fit en <time class="nowrap" datetime="1985-10" data-sort-value="1985-10">octobre 1985</time>. En <time>1983</time> le nom «&nbsp;C++&nbsp;» est inventé, et en <time>1984</time> le nom du langage passa de <i>C with classes</i> à celui de «&nbsp;C++&nbsp;». Parmi les nouvelles fonctionnalités qui furent ajoutées au langage, il y avait les <a href="Fonction_virtuelle" title="Fonction virtuelle">fonctions virtuelles</a>, la <a href="D%C3%A9finition_d'op%C3%A9rateur" title="Définition d'opérateur">surcharge des opérateurs</a> et des <a href="Surcharge_de_fonction" title="Surcharge de fonction">fonctions</a>, les <a href="R%C3%A9f%C3%A9rence_(programmation)" title="Référence (programmation)">références</a>, les <a href="Constante_(programmation_informatique)" title="Constante (programmation informatique)">constantes</a>, le contrôle du <a href="Type_(informatique)" title="Type (informatique)">typage</a> amélioré et les commentaires en fin de ligne. En <a href="1985" title="1985">1985</a> fut publiée la première édition de <span class="lang-en" lang="en"><i><a href="The_C%2B%2B_Programming_Language" title="The C++ Programming Language">The C++ Programming Language</a></i></span>, apportant ainsi une référence importante au langage qui n'avait pas encore de standard officiel. En <time>1989</time>, c'est la sortie de la version 2.0 de C++. Parmi les nouvelles fonctionnalités, il y avait l'<a href="H%C3%A9ritage_multiple" title="Héritage multiple">héritage multiple</a>, les classes abstraites, les fonctions membres statiques, les fonctions membres constantes, et les membres protégés. En <time>1990</time>, <span class="lang-en" lang="en"><i>The Annotated C++ Reference Manual</i></span> («&nbsp;ARM&nbsp;») fut publié apportant les bases du futur standard. Les ajouts de fonctionnalités tardifs qu'il comportait couvraient les templates, les exceptions, les espaces de noms, les nouvelles conversions et le type booléen.
</p><p>Pendant l'évolution du langage C++, la bibliothèque standard évoluait de concert. Le premier ajout à la bibliothèque standard du C++ concernait les flux d'entrées/sorties qui apportaient les fonctionnalités nécessaires au remplacement des fonctions C traditionnelles telles que <i><code>printf</code></i> et <i><code>scanf</code></i>. Ensuite, parmi les ajouts les plus importants, il y avait la <a href="Standard_Template_Library" title="Standard Template Library">Standard Template Library</a>. Après des années de travail, un comité réunissant l'<a href="American_National_Standards_Institute" title="American National Standards Institute">ANSI</a> et l'<a href="Organisation_internationale_de_normalisation" title="Organisation internationale de normalisation">ISO</a> standardisa C++ en <time>1998</time> (ISO/CEI 14882:1998), l'année où le comité de standardisation se réunissait à <a href="Sophia_Antipolis" title="Sophia Antipolis">Sophia Antipolis</a> dans le sud de la France. Pendant quelques années après la sortie officielle du standard, le comité traita des problèmes remontés par les utilisateurs, et publia en 2003 une version corrigée du standard C++.
</p><p>Personne ne possède le langage C++. Il est libre de droits<sup id="cite_ref-9" class="reference"><a href="#cite_note-9"><span class="cite-bracket">[</span>9<span class="cite-bracket">]</span></a></sup>&nbsp;; cependant, le document de standardisation n'est quant à lui pas disponible gratuitement.
</p>
<div class="mw-heading mw-heading2"><h2 id="Fonctionnalités_introduites"><span id="Fonctionnalit.C3.A9s_introduites"></span>Fonctionnalités introduites</h2></div>
<p>On pouvait considérer que C++ «&nbsp;était du C&nbsp;» avec un ajout de fonctionnalités. Cependant, plusieurs programmes syntaxiquement corrects en C ne le sont pas en C++, à commencer bien sûr par ceux qui font usage d'<a href="Identificateur" title="Identificateur">identificateurs</a> correspondant à des mots-clefs en C++. L'architecture d'un programme C++ moderne (C++11) est differente de celle d'un programme en C.
</p><p>Parmi les fonctionnalités ajoutées figurent&nbsp;:
</p>
<ul><li>le typage des «&nbsp;prototypes&nbsp;» de fonctions (repris dans ANSI C89)&nbsp;;</li>
<li>La <a href="Surcharge_des_fonctions" class="mw-redirect" title="Surcharge des fonctions">surcharge des fonctions</a>&nbsp;;</li>
<li>les déclarations reconnues comme instructions (repris dans C99)&nbsp;;</li>
<li>les opérateurs <code>new</code> et <code>delete</code> pour la <a href="Allocateur_(C%2B%2B)" title="Allocateur (C++)">gestion d'allocation mémoire</a>&nbsp;;</li>
<li>le type de données <code>bool</code> (booléen)&nbsp;;</li>
<li>les <a href="R%C3%A9f%C3%A9rence_(informatique)" class="mw-redirect" title="Référence (informatique)">références</a> <code>&amp;</code><sup id="cite_ref-10" class="reference"><a href="#cite_note-10"><span class="cite-bracket">[</span>10<span class="cite-bracket">]</span></a></sup>;</li>
<li>les variables et les fonctions membres <code>const</code> (repris partiellement par C à la fin des <a href="Ann%C3%A9es_1980" title="Années 1980">années 1980</a>)&nbsp;;</li>
<li>les fonctions <code>inline</code> (repris dans C99)&nbsp;;</li>
<li>les paramètres par défaut dans les fonctions&nbsp;;</li>
<li>les référentiels lexicaux (<a href="Espace_de_noms" title="Espace de noms">espaces de noms</a>) et l'opérateur de résolution de portée <code>::</code>&nbsp;;</li>
<li>les <a href="Classe_(informatique)" title="Classe (informatique)">classes</a>, ainsi que tout ce qui y est lié&nbsp;: l'<a href="H%C3%A9ritage_(informatique)" title="Héritage (informatique)">héritage</a>, les fonctions membres, les fonctions membres virtuelles, les <a href="Constructeur_(programmation)" title="Constructeur (programmation)">constructeurs</a> et le <a href="Destructeur" title="Destructeur">destructeur</a>&nbsp;;</li>
<li>la <a href="Surcharge_des_op%C3%A9rateurs" class="mw-redirect" title="Surcharge des opérateurs">surcharge des opérateurs</a>&nbsp;;</li>
<li>les <a href="Template_(programmation)" title="Template (programmation)">templates</a>&nbsp;;</li>
<li>la <a href="Syst%C3%A8me_de_gestion_d'exceptions" title="Système de gestion d'exceptions">gestion d'exceptions</a>&nbsp;;</li>
<li>l'identification de type pendant l'exécution (<a href="RTTI" class="mw-redirect" title="RTTI">RTTI</a>&nbsp;: <span class="lang-en" lang="en"><i>run-time type information</i></span>)&nbsp;;</li>
<li>le <a href="Commentaire_(informatique)" title="Commentaire (informatique)">commentaire</a> sur une ligne introduit par <code>//</code> (existant dans <a href="BCPL" title="BCPL">BCPL</a>, repris dans C99)&nbsp;;</li>
<li>les références de rvalue <code>&amp;&amp;</code> (C++11)&nbsp;;</li>
<li>la déduction de type à la compilation via <code>auto</code> (C++11)&nbsp;;</li>
<li>les expressions constantes <code>constexpr</code> (C++11)<sup id="cite_ref-11" class="reference"><a href="#cite_note-11"><span class="cite-bracket">[</span>11<span class="cite-bracket">]</span></a></sup>;</li>
<li>les <a href="Fonction_anonyme" title="Fonction anonyme">fonctions lambda</a> (C++11, étendu dans tous les standards publiés depuis)&nbsp;;</li>
<li>les boucles <a href="Boucle_for" title="Boucle for">for</a> basées sur une plage (C++11, étendu en C++20)&nbsp;;</li>
<li>les modules via <code>import</code>, <code>export</code> et <code>module</code> (C++20)&nbsp;;</li>
<li>les contraintes et concepts via <code>concept</code> et <code>requires</code> (C++20)&nbsp;;</li>
<li>les fonctions immédiates <code>consteval</code> (C++20)&nbsp;;</li>
<li>les <a href="Coroutine" title="Coroutine">coroutines</a> (C++20)&nbsp;;</li></ul>
<p>La <a href="Compilateur" title="Compilateur">compilation</a> d'un programme en C++ effectue également un contrôle plus minutieux du typage.
</p>
<div class="mw-heading mw-heading2"><h2 id="Bibliothèque_standard"><span id="Biblioth.C3.A8que_standard"></span>Bibliothèque standard</h2></div>


<p>La <a href="Biblioth%C3%A8que_standard_du_C%2B%2B" title="Bibliothèque standard du C++">bibliothèque standard du C++</a> englobe la <a href="Standard_Template_Library" title="Standard Template Library">Standard Template Library</a> (STL) qui met à la disposition du programmeur des outils puissants comme des collections (conteneurs) et des itérateurs.
</p><p>À l'origine, la STL était une bibliothèque développée par <a href="Alexander_Stepanov" title="Alexander Stepanov">Alexander Stepanov</a> qui travaillait pour <a href="Hewlett-Packard" title="Hewlett-Packard">Hewlett-Packard</a>. Dans la norme, celle-ci n'est pas appelée STL, car elle est considérée comme faisant partie de la bibliothèque standard de C++. Toutefois, beaucoup de personnes l'appellent encore de cette manière pour distinguer d'une part, les fonctions d'entrées/sorties comprises dans cette bibliothèque et, d'autre part, celles fournies par la bibliothèque C.
</p><p>Comme en C, l'utilisation d'une bibliothèque peut se faire par l'intermédiaire de la directive <code>#include</code> (suivie du nom du fichier d'en-tête), et certaines d'entre elles (<code>cmath</code>, <code>thread</code>,&nbsp;<abbr class="abbr" title="et cetera">etc.</abbr>) nécessitent d'être <a href="%C3%89dition_de_liens" title="Édition de liens">liées</a> explicitement. Depuis C++20 le mot clé <code>import</code> peut servir à des fins similaires.
</p>
<div class="mw-heading mw-heading2"><h2 id="Programmation_orientée_objet"><span id="Programmation_orient.C3.A9e_objet"></span>Programmation orientée objet</h2></div>

<p>Le langage C++ utilise les concepts de la <a href="Programmation_orient%C3%A9e_objet" title="Programmation orientée objet">programmation orientée objet</a> et permet entre autres&nbsp;:
</p>
<ul><li>la création de <a href="Classe_(informatique)" title="Classe (informatique)">classes</a>&nbsp;;
<ul><li>l'<a href="Encapsulation_(programmation)" title="Encapsulation (programmation)">encapsulation</a>&nbsp;;</li>
<li>des relations entre les <a href="Classe_(informatique)" title="Classe (informatique)">classes</a>&nbsp;:
<ul><li>la <a href="Composition_(programmation)" title="Composition (programmation)">composition de classes</a> (<a href="Diagramme_de_classes#Composition" title="Diagramme de classes">composition dans un diagramme de classes</a>),</li>
<li>l'association de classes&nbsp;<a href="https://en.wikipedia.org/wiki/Association_(object-oriented_programming)" class="extiw external" title="en:Association (object-oriented programming)"><span class="indicateur-langue" title="Article en anglais&nbsp;: «&nbsp;Association (object-oriented programming)&nbsp;»">(en)</span></a> (<a href="Diagramme_de_classes#Association" title="Diagramme de classes">association dans un diagramme de classes</a>),</li>
<li>l'agrégation de classes (<a href="Diagramme_de_classes#Agrégation" title="Diagramme de classes">agrégation dans un diagramme de classes</a>),</li>
<li>la dépendance (<a href="Diagramme_de_classes#Dépendance" title="Diagramme de classes">dépendance dans un diagramme de classes</a>),</li>
<li>l'<a href="H%C3%A9ritage_(informatique)" title="Héritage (informatique)">héritage</a> simple et <a href="H%C3%A9ritage_multiple" title="Héritage multiple">multiple</a> (<a href="Diagramme_de_classes#Héritage" title="Diagramme de classes">héritage dans un diagramme de classes</a>)&nbsp;;</li></ul></li></ul></li>
<li>le <a href="Polymorphisme_(informatique)" title="Polymorphisme (informatique)">polymorphisme</a>&nbsp;;</li>
<li>l'<a href="Abstraction_(informatique)" title="Abstraction (informatique)">abstraction</a>&nbsp;;</li>
<li>la <a href="G%C3%A9n%C3%A9ricit%C3%A9" title="Généricité">généricité</a>&nbsp;;</li>
<li>la <a href="M%C3%A9ta-programmation" class="mw-redirect" title="Méta-programmation">méta-programmation</a>.</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Encapsulation">Encapsulation</h2></div>
<p>L'encapsulation permet de faire abstraction du fonctionnement interne (c'est-à-dire la mise en œuvre) d'une classe et ainsi de ne se préoccuper que des services rendus par celle-ci. C++ met en œuvre l'encapsulation en permettant de déclarer les membres d'une classe avec le mot réservé <code>public</code>, <code>private</code> ou <code>protected</code>. Ainsi, lorsqu'un membre est déclaré&nbsp;:
</p>
<ul><li><code>public</code>, il sera accessible depuis n'importe quelle fonction&nbsp;;</li>
<li><code>private</code>, il sera uniquement accessible d'une part, depuis les fonctions qui sont membres de la classe et, d'autre part, depuis les fonctions autorisées explicitement par la classe (par l'intermédiaire du mot réservé <code>friend</code>)&nbsp;;</li>
<li><code>protected</code>, il aura les mêmes restrictions que s'il était déclaré <code>private</code>, mais il sera en revanche accessible par les classes filles.</li></ul>
<p>C++ n'impose pas l'encapsulation des membres dans leurs classes. On pourrait donc déclarer tous les membres publics, mais en perdant une partie des bénéfices apportés par la programmation orientée objet. Il est de bon usage de déclarer toutes les données privées, ou au moins protégées, et de rendre publiques les fonctions membres agissant sur ces données. Ceci permet de cacher les détails de la mise en œuvre de la classe.
</p>
<div class="mw-heading mw-heading2"><h2 id="«_Hello_world_»"><span id=".C2.AB_Hello_world_.C2.BB"></span><span class="citation not_fr_quote" lang="en">«&nbsp;<span class="italique">Hello world</span>&nbsp;»</span></h2></div>
<p>Voici l'exemple de <i><b><a href="Hello_world" title="Hello world">Hello world</a></b></i> donné dans <i><span class="lang-en" lang="en">The C++ Programming Language, Third Edition</span></i><sup id="cite_ref-12" class="reference"><a href="#cite_note-12"><span class="cite-bracket">[</span>12<span class="cite-bracket">]</span></a></sup> de <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a>&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="cpf">&lt;iostream&gt;</span>

<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"Hello, new world!</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>Dans l'exemple ci-dessus, le code source <code>std::cout &lt;&lt; "Hello, new world!\n"</code> envoie la chaîne de caractères <code>"Hello, new world!\n"</code> à l'objet global <code>cout</code>, défini dans l'espace de noms standard <code>std</code>, grâce à l'opérateur surchargé <code>&lt;&lt;</code>. Cette opération affiche dans la console du programme la chaîne de caractères <code>"Hello, new world!\n"</code>.
</p><p>Avec l'ajout des modules dans le langage et de la fonction print dans la bibliothèque standard, l'exemple Hello World peut depuis C++23 être écrit&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">import</span><span class="w"> </span><span class="n">std</span><span class="p">;</span>

<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="w"> </span><span class="p">()</span>
<span class="p">{</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">println</span><span class="p">(</span><span class="s">"Hello, World!"</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Espace_de_noms">Espace de noms</h3></div>
<p>En C++, le mot clef <code>namespace</code> permet de définir et de nommer des <a href="Espace_de_noms#En_informatique" title="Espace de noms">espaces de noms</a> (<span class="lang-en" lang="en"><i>namespaces</i></span>), notion déjà présente en <a href="C_(langage)" title="C (langage)">langage C</a>&nbsp;; en effet, le corps d'une <a href="Routine_(informatique)" title="Routine (informatique)">routine</a>, d'une <a href="Structure_de_contr%C3%B4le" title="Structure de contrôle">structure de contrôle de flux d'exécution</a>, d'une <a href="Structure_de_donn%C3%A9es" title="Structure de données">structure de données</a> ou d'une section de code (délimitée par les accolades <code>{</code> et <code>}</code>) constitue un espace de noms. En C++, le corps d'une classe, à l'instar du corps d'une structure de données, constitue aussi un espace de noms.
</p><p>Dans différents espaces de noms, on peut ainsi définir des entités (routines, variables, etc.) ayant le même identificateur. L'ambiguïté est résolue en utilisant le nom de l'espace de nom devant l'opérateur de portée (<code>::</code>) pour indiquer l'espace de noms dans lequel on veut accéder. L'espace de noms global du programme n'a pas de nom. Pour accéder à une entité globale, cachée par une entité locale par exemple, on utilise l'opérateur de portée précédé d'aucun nom.
</p>
<div class="mw-heading mw-heading2"><h2 id="Directive_«_using_»"><span id="Directive_.C2.AB_using_.C2.BB"></span>Directive «&nbsp;using&nbsp;»</h2></div>
<p>Il est possible de spécifier un <a href="Espace_de_noms#En_informatique" title="Espace de noms">espace de noms</a> précis à utiliser afin d'éviter d'avoir à recourir à l'opérateur de résolution de portée. Pour cela, le mot-clé <code>using</code> est utilisé avec cette syntaxe&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">using</span><span class="w"> </span><span class="k">namespace</span><span class="w"> </span><span class="nn">nom_du_namespace</span><span class="p">;</span>
<span class="c1">// ou</span>
<span class="k">using</span><span class="w"> </span><span class="n">nom_d_un_symbole</span><span class="p">;</span>
<span class="c1">// ou</span>
<span class="k">using</span><span class="w"> </span><span class="k">enum</span><span class="w"> </span><span class="nc">nom_d_un_enum_class</span><span class="p">;</span><span class="w"> </span><span class="c1">// C++20</span>
</pre></div>
<p>Ainsi, pour utiliser la variable <code>cout</code> définie dans le <i>namespace</i> standard sans utiliser l'opérateur de résolution de portée, il est possible d'écrire <code>using namespace std;</code> ou <code>using std::cout;</code>. Cela est valable pour tous les espaces de noms. Cette instruction se place en général au début du code source&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;iostream&gt;</span>
<span class="k">using</span><span class="w"> </span><span class="k">namespace</span><span class="w"> </span><span class="nn">std</span><span class="p">;</span>

<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"Hello, new world!</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>Il est aussi possible, et conseillé, d'importer un symbole particulier, ou de placer cette instruction dans une fonction afin de limiter la portée&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;iostream&gt;</span>

<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">using</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="p">;</span>
<span class="w"> </span><span class="c1">// std::cout est disponible sans utilisation de std::</span>
<span class="w"> </span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"Hello, new world!"</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span><span class="w"> </span><span class="c1">// mais pas std::endl (endline)</span>
<span class="p">}</span>

<span class="kt">void</span><span class="w"> </span><span class="nf">foo</span><span class="p">()</span>
<span class="p">{</span>
<span class="w"> </span><span class="c1">// std::cout n'est plus disponible sans utilisation de std::</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"Hello, new world!"</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>Le mot-clé <code>using</code> peut aussi être utilisé dans les classes. Si une classe B hérite d'une classe A, elle peut grâce à ce mot-clé passer des membres <code>protected</code> de A en <code>public</code> dans B, ou encore démasquer une fonction membre de A qui le serait par une fonction membre de B de même nom&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;iostream&gt;</span><span class="c1"> </span>

<span class="c1">// Déclaration de la classe de base A.</span>
<span class="k">class</span><span class="w"> </span><span class="nc">A</span>
<span class="p">{</span>
<span class="k">protected</span><span class="o">:</span>
<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">f</span><span class="p">()</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"A::f()</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>

<span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">g</span><span class="p">()</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"A::g()</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">};</span>

<span class="c1">// Déclaration de la classe B héritant de A.</span>
<span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="n">A</span>
<span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="k">using</span><span class="w"> </span><span class="n">A</span><span class="o">::</span><span class="n">f</span><span class="p">;</span><span class="w"> </span><span class="c1">// rend public A::f()</span>
<span class="p">};</span>

<span class="c1">// Déclaration de la classe C héritant de A.</span>
<span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="o">:</span><span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="n">A</span>
<span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">g</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">Val</span><span class="p">)</span><span class="w"> </span><span class="c1">// masque A::g()</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"C::g(int)</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">};</span>

<span class="c1">// Déclaration de la classe D héritant de A.</span>
<span class="k">class</span><span class="w"> </span><span class="nc">D</span><span class="o">:</span><span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="n">A</span>
<span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="kt">void</span><span class="w"> </span><span class="n">g</span><span class="p">(</span><span class="kt">int</span><span class="w"> </span><span class="n">Val</span><span class="p">)</span><span class="w"> </span><span class="c1">// masque A::g()</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="s">"D::g(int)"</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="w"> </span><span class="k">using</span><span class="w"> </span><span class="n">A</span><span class="o">::</span><span class="n">g</span><span class="p">;</span><span class="w"> </span><span class="c1">// démasque A::g()</span>
<span class="p">};</span>

<span class="kt">int</span><span class="w"> </span><span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="w"> </span><span class="n">A</span><span class="w"> </span><span class="n">a</span><span class="p">;</span>
<span class="w"> </span><span class="n">B</span><span class="w"> </span><span class="n">b</span><span class="p">;</span>
<span class="w"> </span><span class="n">C</span><span class="w"> </span><span class="n">c</span><span class="p">;</span>
<span class="w"> </span><span class="n">D</span><span class="w"> </span><span class="n">d</span><span class="p">;</span>

<span class="w"> </span><span class="c1">// a.f(); // impossible car f est protégé dans A</span>
<span class="w"> </span><span class="n">a</span><span class="p">.</span><span class="n">g</span><span class="p">();</span>

<span class="w"> </span><span class="n">b</span><span class="p">.</span><span class="n">f</span><span class="p">();</span><span class="w"> </span><span class="c1">// possible car A::f est publique dans B.</span>

<span class="w"> </span><span class="c1">// c.g(); // impossible car A::g() est masquée par C::g(int) dans C</span>
<span class="w"> </span><span class="n">c</span><span class="p">.</span><span class="n">g</span><span class="p">(</span><span class="mi">6</span><span class="p">);</span><span class="w"> </span><span class="c1">// possible car C::g(int Val) est masquée par C::g(int) dans C</span>

<span class="w"> </span><span class="n">d</span><span class="p">.</span><span class="n">g</span><span class="p">();</span><span class="w"> </span><span class="c1">// possible car A::g() est démasquée dans D</span>
<span class="w"> </span><span class="n">d</span><span class="p">.</span><span class="n">g</span><span class="p">(</span><span class="mi">5</span><span class="p">);</span><span class="w"> </span><span class="c1">// possible car D::g() est démasquée dans D</span>
<span class="p">}</span>
</pre></div>
<p>Le programme ci-dessus affiche&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="n">A</span><span class="o">::</span><span class="n">g</span><span class="p">()</span>
<span class="n">A</span><span class="o">::</span><span class="n">f</span><span class="p">()</span>
<span class="n">C</span><span class="o">::</span><span class="n">g</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span>
<span class="n">A</span><span class="o">::</span><span class="n">g</span><span class="p">()</span>
<span class="n">D</span><span class="o">::</span><span class="n">g</span><span class="p">(</span><span class="kt">int</span><span class="p">)</span>
</pre></div>
<p>Il est aussi possible de définir un nouveau nom pour un namespace&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr mw-highlight-lines" dir="ltr"><pre><span></span><span class="linenos" data-line="1"></span><span class="k">namespace</span><span class="w"> </span><span class="nn">fs</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="nn">std</span><span class="o">::</span><span class="nn">filesystem</span><span class="p">;</span>
<span class="linenos" data-line="2"></span><span class="c1">// on peut alors écrire fs::path au lieu de std::filesystem::path</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Déclaration_et_définition_de_classe"><span id="D.C3.A9claration_et_d.C3.A9finition_de_classe"></span>Déclaration et définition de classe</h2></div>
<p>Il est d'usage de séparer <i>prototype</i> (déclaration) et <i>implémentation</i> (définition) de classe dans deux fichiers&nbsp;: la déclaration se fait dans un fichier d'en-tête (dont l'extension varie selon les préférences des développeurs&nbsp;: sans extension dans le standard, .h comme en C, .hh ou .hpp ou .hxx pour différencier le code source C++ du C) alors que la définition se fait dans un fichier source (d'extension également variable&nbsp;: .c comme en C, .cc ou .cpp ou .cxx pour différencier C++ du C).
</p>
<div class="mw-heading mw-heading3"><h3 id="Déclaration_de_classe"><span id="D.C3.A9claration_de_classe"></span>Déclaration de classe</h3></div>
<p>Exemple de la déclaration d'une classe comportant des <a href="Attribut_(informatique)" title="Attribut (informatique)">attributs</a> privés et des <a href="M%C3%A9thode_(informatique)" title="Méthode (informatique)">fonctions membres</a> publiques&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">// messageinternet.hpp</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;string_view&gt;</span>

<span class="k">class</span><span class="w"> </span><span class="nc">MessageInternet</span>
<span class="p">{</span>
<span class="k">private</span><span class="o">:</span><span class="w"> </span><span class="c1">// Ici, private: est optionnel car il est par défaut.</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">m_sujet</span><span class="p">;</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">m_expediteur</span><span class="p">;</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">m_destinataire</span><span class="p">;</span><span class="w"> </span><span class="c1">// attributs</span>
<span class="w"> </span>
<span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="c1">// constructeur</span>
<span class="w"> </span><span class="n">MessageInternet</span><span class="p">(</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">sujet</span><span class="p">,</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">expediteur</span><span class="p">,</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">destinataire</span><span class="p">);</span>
<span class="w"> </span><span class="c1">// fonctions membres&nbsp;:</span>
<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">sujet</span><span class="p">();</span>
<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">expediteur</span><span class="p">();</span>
<span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">destinataire</span><span class="p">();</span>
<span class="p">};</span>
</pre></div>
<div class="mw-heading mw-heading3"><h3 id="Définition_de_classe"><span id="D.C3.A9finition_de_classe"></span>Définition de classe</h3></div>
<p>Le nom d'une fonction membre déclarée par une classe doit nécessairement être précédé du nom de la classe suivi de l'opérateur de résolution de portée <code>::</code>.
</p><p>
Exemple de définition des fonctions membres d'une classe (celle déclarée précédemment)&nbsp;:</p><div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="c1">// messageinternet.cpp</span>
<span class="cp">#include</span><span class="w"> </span><span class="cpf">"messageinternet.hpp"</span>

<span class="n">MessageInternet</span><span class="o">::</span><span class="n">MessageInternet</span><span class="p">(</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">sujet</span><span class="p">,</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">expediteur</span><span class="p">,</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string_view</span><span class="w"> </span><span class="n">destinataire</span><span class="p">)</span>
<span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">m_sujet</span><span class="p">(</span><span class="n">sujet</span><span class="p">),</span>
<span class="w"> </span><span class="n">m_expediteur</span><span class="p">(</span><span class="n">expediteur</span><span class="p">),</span>
<span class="w"> </span><span class="n">m_destinataire</span><span class="p">(</span><span class="n">destinataire</span><span class="p">)</span>
<span class="w"> </span><span class="p">{}</span>

<span class="k">auto</span><span class="w"> </span><span class="n">MessageInternet</span><span class="o">::</span><span class="n">sujet</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">m_sujet</span><span class="p">;</span><span class="w"> </span><span class="p">}</span>
<span class="k">auto</span><span class="w"> </span><span class="n">MessageInternet</span><span class="o">::</span><span class="n">expediteur</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">m_expediteur</span><span class="p">;</span><span class="w"> </span><span class="p">}</span>
<span class="k">auto</span><span class="w"> </span><span class="n">MessageInternet</span><span class="o">::</span><span class="n">destinataire</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">m_destinataire</span><span class="p">;</span><span class="w"> </span><span class="p">}</span>
</pre></div>
<div class="mw-heading mw-heading2"><h2 id="Modèles"><span id="Mod.C3.A8les"></span>Modèles</h2></div>

<p>Les Modèles (ou templates) permettent d'écrire des variables, des fonctions et des classes en paramétrant le type de certains de leurs constituants (type des paramètres ou type de retour pour une fonction, type des éléments pour une classe collection par exemple). Les modèles permettent d'écrire du code générique, c'est-à-dire qui peut servir pour une <i>famille</i> de fonctions ou de classes qui ne diffèrent que par le type de leurs constituants.
</p>
<div class="mw-heading mw-heading3"><h3 id="Paramètres_des_modèles"><span id="Param.C3.A8tres_des_mod.C3.A8les"></span>Paramètres des modèles</h3></div>
<p>Les paramètres peuvent être de différentes sortes&nbsp;:
</p>
<ul><li>types simples, tels que les classes ou les types élémentaires (<code>int</code>, <code>double</code>, etc.)&nbsp;;</li>
<li>tableaux de taille constante, dont la taille, déduite par le compilateur, peut être utilisée dans l'instanciation du <a href="Template_(programmation)" title="Template (programmation)">modèle</a>&nbsp;;</li>
<li>constantes scalaires, c'est-à-dire de type entier (<code>int</code>, <code>char</code>, <code>bool</code>), mais pas flottant (<code>float</code>, <code>double</code>) car leur représentation binaire ne fait pas partie de la norme du langage (jusqu'en C++20 où ils sont autorisés<sup id="cite_ref-13" class="reference"><a href="#cite_note-13"><span class="cite-bracket">[</span>13<span class="cite-bracket">]</span></a></sup>)&nbsp;;</li>
<li>templates, dont la définition doit être passée en paramètre, ce qui permet notamment de s'appuyer sur la définition abstraite, par exemple, d'une collection&nbsp;;</li>
<li>pointeurs ou références, à condition que leur valeur soit définie à l'édition de liens&nbsp;;</li>
<li>fonction membre d'une classe, dont la signature et la classe doivent être aussi passées en paramètres&nbsp;;</li>
<li>attribut d'une classe, dont le type et la classe doivent être aussi passés en paramètres.</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Utilité_des_modèles"><span id="Utilit.C3.A9_des_mod.C3.A8les"></span>Utilité des modèles</h3></div>
<p>En programmation, il faut parfois écrire de nombreuses versions d'une même fonction ou classe suivant les types de données manipulées. Par exemple, un tableau de <code>int</code> ou un tableau de <code>double</code> sont très semblables, et les fonctions de tri ou de recherche dans ces tableaux sont identiques, la seule différence étant le type des données manipulées. En résumé, l'utilisation des templates permet de «&nbsp;paramétrer&nbsp;» le type des données manipulées.
</p><p>Les avantages des modèles sont&nbsp;:
</p>
<ul><li>des écritures uniques pour les fonctions et les classes&nbsp;;</li>
<li>moins d'erreurs dues à la réécriture&nbsp;;</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Exemple_de_modèles"><span id="Exemple_de_mod.C3.A8les"></span>Exemple de modèles</h3></div>
<p>Dans la bibliothèque standard C++, on trouve de nombreux templates. On citera à titre d'exemple, les entrées/sorties, les chaînes de caractères ou les conteneurs. Les classes <code>string</code>, <code>istream</code>, <code>ostream</code> et <code>iostream</code> sont toutes des instanciations de type <code>char</code>.
</p><p>Les fonctions de recherche et de tri sont aussi des templates écrits et utilisables avec de nombreux types.
</p>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;string&gt;</span>

<span class="k">template</span><span class="o">&lt;</span><span class="k">typename</span><span class="w"> </span><span class="nc">T</span><span class="o">&gt;</span>
<span class="n">T</span><span class="w"> </span><span class="n">max</span><span class="p">(</span><span class="n">T</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">T</span><span class="w"> </span><span class="n">b</span><span class="p">)</span><span class="w"> </span><span class="c1">// Une fonction similaire est aussi définie dans le header &lt;algorithm&gt;</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">&lt;</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">?</span><span class="w"> </span><span class="n">b</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">a</span><span class="p">;</span>
<span class="p">}</span>

<span class="kt">int</span><span class="w"> </span><span class="n">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">i</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="w"> </span><span class="mi">5</span><span class="p">);</span>
<span class="w"> </span><span class="kt">char</span><span class="w"> </span><span class="n">ch</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max</span><span class="p">(</span><span class="sc">'e'</span><span class="p">,</span><span class="w"> </span><span class="sc">'b'</span><span class="p">);</span>
<span class="w"> </span><span class="k">using</span><span class="w"> </span><span class="k">namespace</span><span class="w"> </span><span class="nn">std</span><span class="o">::</span><span class="nn">string_literals</span><span class="p">;</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="w"> </span><span class="n">str</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max</span><span class="p">(</span><span class="s">"hello"</span><span class="n">s</span><span class="p">,</span><span class="w"> </span><span class="s">"world"</span><span class="n">s</span><span class="p">);</span>
<span class="w"> </span><span class="kt">float</span><span class="w"> </span><span class="n">fp</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">max</span><span class="o">&lt;</span><span class="kt">float</span><span class="o">&gt;</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="w"> </span><span class="mf">2.2f</span><span class="p">);</span><span class="w"> </span><span class="c1">// type paramétré donné explicitement</span>
<span class="w"> </span><span class="c1">// (obligatoire avec ces paramètres de types différents)</span>
<span class="p">}</span>
</pre></div>
<p>Dans la ligne <code>float fp = max&lt;float&gt;(1, 2.2f);</code>, on doit explicitement donner le type <code>float</code> pour le type paramétré <code>T</code> car le compilateur ne déduit pas le type de <code>T</code> lorsqu'on passe en même temps un <code>int</code> (<code>1</code>) et un <code>float</code> (<code>2.2f</code>).
</p>
<div class="mw-heading mw-heading3"><h3 id="Spécialisation_des_templates"><span id="Sp.C3.A9cialisation_des_templates"></span>Spécialisation des templates</h3></div>
<p>Un template donné peut avoir plusieurs instanciations possibles selon les types donnés en paramètres. Si un seul paramètre est spécialisé, on parle de <i>spécialisation partielle</i>. Ceci permet par exemple&nbsp;:
</p>
<ul><li>de choisir un type de calcul selon qu'un type est un entier, un flottant, une chaîne de caractères, etc. Spécialisons l'exemple précédent pour le cas des pointeurs de chaînes de caractères&nbsp;:</li></ul>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;cstring&gt;</span>

<span class="k">template</span><span class="o">&lt;&gt;</span>
<span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">max</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="k">const</span><span class="w"> </span><span class="kt">char</span><span class="o">*</span><span class="w"> </span><span class="n">b</span><span class="p">)</span>
<span class="p">{</span>
<span class="w"> </span><span class="c1">// Normalement, le résultat d'une comparaison directe</span>
<span class="w"> </span><span class="c1">// entre deux chaînes de caractères est un comportement non défini;</span>
<span class="w"> </span><span class="c1">// utiliser std::strcmp le rend défini.</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">strcmp</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="w"> </span><span class="n">b</span><span class="p">)</span><span class="w"> </span><span class="o">&gt;</span><span class="w"> </span><span class="mi">0</span><span class="w"> </span><span class="o">?</span><span class="w"> </span><span class="n">a</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="n">b</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<ul><li>d'effectuer au moment de la compilation des calculs arithmétiques, si et seulement si tous les arguments sont connus à ce moment. Un exemple classique est le calcul de la fonction <a href="Factorielle" title="Factorielle">factorielle</a>&nbsp;:</li></ul>
<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre><span></span><span class="k">template</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span><span class="w"> </span><span class="n">N</span><span class="o">&gt;</span>
<span class="k">struct</span><span class="w"> </span><span class="nc">Factorielle</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">static</span><span class="w"> </span><span class="k">constexpr</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">N</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">Factorielle</span><span class="o">&lt;</span><span class="n">N</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="o">&gt;::</span><span class="n">value</span><span class="p">;</span>
<span class="p">};</span>

<span class="k">template</span><span class="o">&lt;&gt;</span>
<span class="k">struct</span><span class="w"> </span><span class="nc">Factorielle</span><span class="o">&lt;</span><span class="mi">0</span><span class="o">&gt;</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">static</span><span class="w"> </span><span class="k">constexpr</span><span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span><span class="w"> </span><span class="n">value</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
<span class="p">};</span>
</pre></div><p>À partir de C++14 pour arriver aux mêmes fins nous pourrions aussi utiliser les variables templates&nbsp;:</p><div class="mw-highlight mw-highlight-lang-c++ mw-content-ltr" dir="ltr"><pre><span></span><span class="k">template</span><span class="o">&lt;</span><span class="n">std</span><span class="o">::</span><span class="kt">size_t</span><span class="w"> </span><span class="n">N</span><span class="o">&gt;</span>
<span class="k">constexpr</span><span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">factorielle</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="n">N</span><span class="w"> </span><span class="o">*</span><span class="w"> </span><span class="n">factorielle</span><span class="o">&lt;</span><span class="n">N</span><span class="w"> </span><span class="o">-</span><span class="w"> </span><span class="mi">1</span><span class="o">&gt;</span><span class="p">;</span>

<span class="k">template</span><span class="o">&lt;&gt;</span>
<span class="k">constexpr</span><span class="w"> </span><span class="k">auto</span><span class="w"> </span><span class="n">factorielle</span><span class="o">&lt;</span><span class="mi">0</span><span class="o">&gt;</span><span class="w"> </span><span class="o">=</span><span class="w"> </span><span class="mi">1</span><span class="p">;</span>
</pre></div><p>Ainsi nous pouvons écrire <code>factorielle&lt;8&gt;;</code> à la place de <code>Factorielle&lt;8&gt;::value;</code>.
</p><div class="mw-heading mw-heading3"><h3 id="SFINAE">SFINAE</h3></div>
<p>Le mécanisme décrit par l'abréviation SFINAE (<i>Substitution Failure Is Not an Error</i>) permet de surcharger un template par plusieurs classes (ou fonctions), même si certaines spécialisations, par exemple, ne peuvent pas être utilisées pour tous les paramètres de templates. Le nom décrit précisément le fonctionnement du mécanisme, littéralement l’acronyme de «&nbsp;Un échec de substitution n'est pas une erreur&nbsp;», le compilateur, lors de la substitution, ignore alors les <i>instanciations</i> inapplicables, au lieu d'émettre une erreur de compilation. Par exemple&nbsp;:
</p>
<div class="mw-highlight mw-highlight-lang-c++ mw-content-ltr" dir="ltr"><pre><span></span><span class="cp">#include</span><span class="w"> </span><span class="cpf">&lt;iostream&gt;</span>

<span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="w"> </span>
<span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">foo</span><span class="p">()</span><span class="w"> </span><span class="k">const</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">3</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">};</span>

<span class="k">class</span><span class="w"> </span><span class="nc">B</span>
<span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="w"> </span><span class="kt">int</span><span class="w"> </span><span class="n">bar</span><span class="p">()</span><span class="w"> </span><span class="k">const</span>
<span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="mi">5</span><span class="p">;</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">};</span>

<span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="w"> </span><span class="o">:</span><span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="n">A</span><span class="p">,</span><span class="w"> </span><span class="k">public</span><span class="w"> </span><span class="n">B</span><span class="w"> </span><span class="p">{};</span>

<span class="k">template</span><span class="w"> </span><span class="o">&lt;</span><span class="k">typename</span><span class="w"> </span><span class="nc">T</span><span class="o">&gt;</span>
<span class="k">auto</span><span class="w"> </span><span class="n">f</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">T</span><span class="o">&amp;</span><span class="w"> </span><span class="n">f</span><span class="p">)</span><span class="w"> </span><span class="o">-&gt;</span><span class="w"> </span><span class="k">decltype</span><span class="p">(</span><span class="n">f</span><span class="p">.</span><span class="n">foo</span><span class="p">())</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">f</span><span class="p">.</span><span class="n">foo</span><span class="p">();</span>
<span class="p">}</span>

<span class="k">template</span><span class="w"> </span><span class="o">&lt;</span><span class="k">typename</span><span class="w"> </span><span class="nc">T</span><span class="o">&gt;</span>
<span class="k">auto</span><span class="w"> </span><span class="n">f</span><span class="p">(</span><span class="k">const</span><span class="w"> </span><span class="n">T</span><span class="o">&amp;</span><span class="w"> </span><span class="n">f</span><span class="p">)</span><span class="w"> </span><span class="o">-&gt;</span><span class="w"> </span><span class="k">decltype</span><span class="p">(</span><span class="n">f</span><span class="p">.</span><span class="n">bar</span><span class="p">())</span>
<span class="p">{</span>
<span class="w"> </span><span class="k">return</span><span class="w"> </span><span class="n">f</span><span class="p">.</span><span class="n">bar</span><span class="p">();</span>
<span class="p">}</span>

<span class="kt">int</span><span class="w"> </span><span class="n">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="w"> </span><span class="n">A</span><span class="w"> </span><span class="n">a</span><span class="p">{};</span>
<span class="w"> </span><span class="n">B</span><span class="w"> </span><span class="n">b</span><span class="p">{};</span>
<span class="w"> </span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">f</span><span class="p">(</span><span class="n">a</span><span class="p">)</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="sc">'\n'</span><span class="p">;</span><span class="w"> </span><span class="c1">// affiche 3 en appelant a.foo()</span>
<span class="w"> </span><span class="n">std</span><span class="o">::</span><span class="n">cout</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="n">f</span><span class="p">(</span><span class="n">b</span><span class="p">)</span><span class="w"> </span><span class="o">&lt;&lt;</span><span class="w"> </span><span class="sc">'\n'</span><span class="p">;</span><span class="w"> </span><span class="c1">// affiche 5 en appelant b.bar()</span>

<span class="w"> </span><span class="c1">// std::cout &lt;&lt; f(C{}) &lt;&lt; '\n';</span>
<span class="w"> </span><span class="c1">// ne compile pas, en effet, C a les deux fonctions membres,</span>
<span class="w"> </span><span class="c1">// ainsi la déduction est ambiguë</span>

<span class="w"> </span><span class="c1">// std::cout &lt;&lt; f(5) &lt;&lt; '\n';</span>
<span class="w"> </span><span class="c1">// ne compile pas, en effet, int n'a aucune des 2 fonctions membres</span>
<span class="p">}</span>
</pre></div>
<p>Ici f est définie deux fois, le type de retour est conditionné par le type donné en paramètre, il est du type du retour de f.foo() dans le premier cas et de celui de f.bar() dans le deuxième cas. Ainsi, si on appelle f avec un objet de la classe A, seule la première fonction fonctionne puisque la classe A n'a pas de fonction membre bar() et donc la substitution est possible avec cette première version mais pas pour la deuxième. Ainsi, f(a) appelle la première version de f, f(b) appelle la deuxième avec le même raisonnement, mais cette fois pour la fonction membre bar().
</p><p>Si lors d'un développement à venir, un développeur venait à écrire une nouvelle classe ayant une fonction membre publique foo ou bien (ou exclusif) bar, il pourrait également utiliser f avec.
</p>
<div class="mw-heading mw-heading2"><h2 id="Polymorphisme_et_fonctions_membres_virtuelles">Polymorphisme et fonctions membres virtuelles</h2></div>
<p>Le <a href="Polymorphisme_(informatique)" title="Polymorphisme (informatique)">polymorphisme</a> d'inclusion est mis en œuvre à l'aide du mécanisme des fonctions membres virtuelles en C++. Une fonction membre est rendue virtuelle par le placement du mot-clé <code>virtual</code> devant la déclaration de la fonction membre dans la classe. Lorsqu'une fonction membre virtuelle est appelée, l'implémentation de la fonction membre exécutée est choisie en fonction du type réel de l'objet. L'appel n'est donc résolu qu'à l'exécution, le type de l'objet ne pouvant pas a priori être connu à la compilation.
</p><p>Le mot-clé <code>virtual</code> indique au compilateur que la fonction membre déclarée virtuelle est susceptible d'être redéfinie dans une classe dérivée. Il suffit alors de dériver une classe et de définir une nouvelle fonction membre de même signature (même nom, paramètres compatibles —&nbsp;voir la notion de covariance). Ainsi l'appel de cette fonction membre sur un objet accédé en tant qu'objet de la classe de base mais appartenant en réalité à la classe dérivée donnera lieu à l'appel de la fonction membre définie dans la classe dérivée.
</p><p>En particulier, il est obligatoire d'utiliser le mot-clé <code>virtual</code> devant la déclaration du destructeur de la classe de base lorsque le programme souhaite pouvoir détruire un objet via un pointeur d'instance de la classe de base au lieu d'un pointeur d'instance de la classe dérivée.
</p><p>Ce type de polymorphisme (le polymorphisme d'inclusion) est dit dynamique. Le mécanisme de la <a href="Surcharge_de_fonction" title="Surcharge de fonction">surcharge de fonction</a> qui est un polymorphisme <i>ad hoc</i> est de type statique. Dans les deux cas il faut appliquer une logique (par exemple&nbsp;: le nombre et le type des paramètres) pour résoudre l'appel. Dans le cas de la surcharge de fonction, la logique est entièrement calculée à la compilation. Ce calcul permet des <a href="Optimisation_de_code" title="Optimisation de code">optimisations</a> rendant le polymorphisme statique plus rapide que sa version dynamique. La liaison dynamique de fonctions membres issues du mécanisme des fonctions membres virtuelles induit souvent une table cachée de résolution des appels, la table virtuelle. Cette table virtuelle augmente le temps nécessaire à l'appel de fonction membre à l'exécution par l'ajout d'une indirection supplémentaire.
</p><p>Le choix entre liaison dynamique et surcharge (polymorphisme dynamique et statique) est typiquement un problème de <a href="Calculable" class="mw-redirect" title="Calculable">calculabilité des appels</a>, ayant souvent pour conséquence finale un choix entre expressivité et performance.
</p><p>Malgré ce dynamisme, le compilateur est capable de «&nbsp;dévirtualiser&nbsp;» les appels de fonctions membres qui peuvent être résolus au moment de la compilation. Dans <a href="GNU_Compiler_Collection" title="GNU Compiler Collection">gcc</a> par exemple, l'option <code>-fdevirtualize</code> lors de la compilation permet cette optimisation, s'il est possible de faire une telle résolution<sup id="cite_ref-14" class="reference"><a href="#cite_note-14"><span class="cite-bracket">[</span>14<span class="cite-bracket">]</span></a></sup>.
</p>
<div class="mw-heading mw-heading2"><h2 id="Outils_de_développement"><span id="Outils_de_d.C3.A9veloppement"></span>Outils de développement</h2></div>
<p>Un programme C++ peut être produit avec des outils qui automatisent le processus de construction. Les plus utilisés pour les «&nbsp;couches basses&nbsp;» sont&nbsp;:
</p>
<ul><li><a href="Make" title="Make">make</a>&nbsp;;</li>
<li><a href="Ninja_(logiciel)" title="Ninja (logiciel)">ninja</a>&nbsp;;</li>
<li>Visual Studio Project (limité à <a href="Microsoft_Visual_C%2B%2B" class="mw-redirect" title="Microsoft Visual C++">Microsoft Visual C++</a>).</li></ul>
<p>Leur pilotage se fait essentiellement aujourd'hui<sup id="cite_ref-15" class="reference"><a href="#cite_note-15"><span class="cite-bracket">[</span>15<span class="cite-bracket">]</span></a></sup> au travers d'outils tels que&nbsp;:
</p>
<ul><li><a href="CMake" title="CMake">CMake</a> (génération portable de <a href="Makefile" class="mw-redirect" title="Makefile">Makefile</a> ou de <a href="Ninja_(logiciel)" title="Ninja (logiciel)">règles pour ninja</a> -- le plus usité depuis fin des années 2010)&nbsp;;</li>
<li>Qmake (outil de la suite <a href="Qt" title="Qt">Qt</a>)&nbsp;;</li>
<li>Les <a href="Autotools" title="Autotools">autotools</a> (Unix/Linux seulement où ils ont longtemps dominé).</li>
<li><a href="Bazel_(logiciel)" title="Bazel (logiciel)">Bazel</a>&nbsp;;</li>
<li><a href="Meson_(logiciel)" title="Meson (logiciel)">Meson</a>&nbsp;;</li>
<li><a href="SCons" title="SCons">SCons</a> (génération portable en Python).</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Environnements_de_développement"><span id="Environnements_de_d.C3.A9veloppement"></span>Environnements de développement</h3></div>
<ul><li><a href="C%2B%2B_Builder" class="mw-redirect" title="C++ Builder">C++ Builder</a> (windows);</li>
<li><a href="CLion_(logiciel)" title="CLion (logiciel)">CLion</a><sup id="cite_ref-16" class="reference"><a href="#cite_note-16"><span class="cite-bracket">[</span>16<span class="cite-bracket">]</span></a></sup>&nbsp;;</li>
<li><a href="Code%3A%3ABlocks" title="Code::Blocks">Code::Blocks</a> (<a href="Logiciel_Libre" class="mw-redirect" title="Logiciel Libre">libre</a>)&nbsp;;</li>
<li><a href="Dev-C%2B%2B" title="Dev-C++">Dev-C++</a> et son extension <a href="Outils_RAD" title="Outils RAD">RAD</a> <a href="WxDev-C%2B%2B" title="WxDev-C++">WxDev-C++</a> (<a href="Logiciel_Libre" class="mw-redirect" title="Logiciel Libre">libre</a>)&nbsp;;</li>
<li><a href="Eclipse_(logiciel)" class="mw-redirect" title="Eclipse (logiciel)">Eclipse</a> avec le plugin CDT<sup id="cite_ref-17" class="reference"><a href="#cite_note-17"><span class="cite-bracket">[</span>17<span class="cite-bracket">]</span></a></sup> (<a href="Open_source" title="Open source">open-source</a>)&nbsp;;</li>
<li><a href="Emacs" title="Emacs">Emacs</a> (<a href="Logiciel_Libre" class="mw-redirect" title="Logiciel Libre">libre</a>)&nbsp;;</li>
<li><a href="KDevelop" title="KDevelop">KDevelop</a> (<a href="Logiciel_Libre" class="mw-redirect" title="Logiciel Libre">libre</a>)&nbsp;;</li>
<li><a href="NetBeans" title="NetBeans">NetBeans</a> (<a href="Open_source" title="Open source">open-source</a>)&nbsp;;</li>
<li><a href="QtCreator" class="mw-redirect" title="QtCreator">QtCreator</a> (<a href="Logiciel_Libre" class="mw-redirect" title="Logiciel Libre">libre</a>)&nbsp;;</li>
<li><a href="Vim" title="Vim">Vim</a>/<a href="Neovim" title="Neovim">Neovim</a> (<a href="Open_source" title="Open source">open-source</a>)&nbsp;;</li>
<li><a href="Microsoft_Visual_C%2B%2B" class="mw-redirect" title="Microsoft Visual C++">Microsoft Visual C++</a> (a été intégré au <a href="Framework" title="Framework">framework</a> Visual Studio; windows);</li>
<li><a href="Xcode" title="Xcode">Xcode</a> (mac).</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Compilateurs">Compilateurs</h3></div>
<ul><li>GCC pour <i><a href="GNU_Compiler_Collection" title="GNU Compiler Collection">GNU Compiler Collection</a></i> (<a href="Logiciel_libre" title="Logiciel libre">libre</a>, <i><a href="Multilangage" title="Multilangage">multilangage</a></i> et <i><a href="Logiciel_multiplate-forme" class="mw-redirect" title="Logiciel multiplate-forme">multiplateforme</a></i>&nbsp;: <a href="UNIX" class="mw-redirect" title="UNIX">UNIX</a>, Windows, DOS, etc.)&nbsp;;</li>
<li><a href="Clang" title="Clang">Clang</a>&nbsp;;</li>
<li><i><a href="Microsoft_Visual_C%2B%2B" class="mw-redirect" title="Microsoft Visual C++">Microsoft Visual C++</a></i> (Windows)&nbsp;;</li>
<li><a href="C%2B%2B_Builder" class="mw-redirect" title="C++ Builder">Embarcadero C++ Builder</a> (Windows)&nbsp;;</li>
<li><a href="Intel_C%2B%2B_Compiler" title="Intel C++ Compiler">Intel C++ Compiler</a> (Windows, <a href="Linux" title="Linux">Linux</a>, <a href="Mac_OS_X" class="mw-redirect" title="Mac OS X">MacOS</a>)&nbsp;;</li>
<li>Open64&nbsp;<a href="https://en.wikipedia.org/wiki/Open64" class="extiw external" title="en:Open64"><span class="indicateur-langue" title="Article en anglais&nbsp;: «&nbsp;Open64&nbsp;»">(en)</span></a> compilateur <a href="Opensource" class="mw-redirect" title="Opensource">opensource</a> d'AMD (<a href="Linux" title="Linux">Linux</a>)&nbsp;;</li>
<li>Digital Mars C/C++ compiler (Windows)&nbsp;;</li>
<li><a href="Open_Watcom" title="Open Watcom">Open Watcom</a>&nbsp;;</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Bibliothèques"><span id="Biblioth.C3.A8ques"></span>Bibliothèques</h3></div>
<ul><li><a href="Boost_(biblioth%C3%A8ques)" title="Boost (bibliothèques)">Boost</a>&nbsp;;</li>
<li><a href="Qt" title="Qt">Qt</a>&nbsp;;</li>
<li><a href="Gtkmm" title="Gtkmm">Gtkmm</a>&nbsp;;</li>
<li><a href="WxWidgets" title="WxWidgets">wxWidgets</a>&nbsp;;</li>
<li><a href="SFML" class="mw-redirect" title="SFML">SFML</a>&nbsp;;</li>
<li><a href="OpenCV" title="OpenCV">OpenCV</a>&nbsp;;</li>
<li>SDLmm, surcouche C++ à la <a href="Simple_DirectMedia_Layer" title="Simple DirectMedia Layer">SDL</a>&nbsp;;</li>
<li><a href="LLVM" title="LLVM">LLVM</a>.</li>
<li>etc.</li></ul>
<div class="mw-heading mw-heading2"><h2 id="Références"><span id="R.C3.A9f.C3.A9rences"></span>Références</h2></div>
<div class="references-small decimal" style=""><div class="mw-references-wrap mw-references-columns"><ol class="references">
<li id="cite_note-1"><span class="mw-cite-backlink"><a href="#cite_ref-1">↑</a> </span><span class="reference-text"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr>
<span class="ouvrage" id="Stroustrup2012"><span class="ouvrage" id="Bjarne_Stroustrup2012">Bjarne Stroustrup, <cite class="italique">Bjarne Stroustrup's FAQ&nbsp;: FAQ de Bjarne Stroustrup</cite>, www.stroustrup.com, modified february 2, 2012. <small style="line-height:1em;">(<a rel="nofollow" class="external text" href="http://www.stroustrup.com/bs_faq.html#invention">lire en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Bjarne+Stroustrup%27s+FAQ&amp;rft.pub=www.stroustrup.com&amp;rft.stitle=FAQ+de+Bjarne+Stroustrup&amp;rft.aulast=Stroustrup&amp;rft.aufirst=Bjarne&amp;rft.date=2012&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span></span>
</li>
<li id="cite_note-wikidata-1cb32e45d32ea7da85b87c5f5ef5b8c3cba362e8-2"><span class="reference-text"><span class="ouvrage">«&nbsp;<a rel="nofollow" class="external text" href="https://www.iso.org/standard/83626.html"><cite style="font-style:normal;"><span class="lang-en" lang="en">ISO/IEC 14882:2024 - Programming languages — C++</span></cite></a>&nbsp;», <time class="nowrap" datetime="2024-10-19" data-sort-value="2024-10-19">19 octobre 2024</time></span></span>
</li>
<li id="cite_note-3"><span class="mw-cite-backlink"><a href="#cite_ref-3">↑</a> </span><span class="reference-text"><span class="ouvrage" id="2011"><cite class="italique">ISO/IEC 14882&nbsp;: 2011&nbsp;: Technologies de l'information -- Langages de programmation -- C++</cite>, ISO, <time class="nowrap" datetime="2011-09-01" data-sort-value="2011-09-01"><abbr class="abbr" title="premier">1<sup>er</sup></abbr> septembre 2011</time> <small style="line-height:1em;">(<a rel="nofollow" class="external text" href="http://www.iso.org/iso/fr/catalogue_detail?csnumber=50372">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=ISO%2FIEC+14882+%3A+2011&amp;rft.pub=ISO&amp;rft.stitle=Technologies+de+l%27information+--+Langages+de+programmation+--+C%2B%2B&amp;rft.date=2011-09-01&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><a href="#cite_ref-4">↑</a> </span><span class="reference-text"><span class="ouvrage" id="2014"><cite class="italique">ISO/IEC 14882&nbsp;: 2014&nbsp;: Technologies de l'information -- Langages de programmation -- C++</cite>, ISO, <time class="nowrap" datetime="2014-12-15" data-sort-value="2014-12-15">15 décembre 2014</time> <small style="line-height:1em;">(<a rel="nofollow" class="external text" href="https://www.iso.org/fr/standard/64029.html">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=ISO%2FIEC+14882+%3A+2014&amp;rft.pub=ISO&amp;rft.stitle=Technologies+de+l%27information+--+Langages+de+programmation+--+C%2B%2B&amp;rft.date=2014-12-15&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>
</li>
<li id="cite_note-5"><span class="mw-cite-backlink"><a href="#cite_ref-5">↑</a> </span><span class="reference-text"><span class="ouvrage" id="2017"><cite class="italique">ISO/IEC 14882&nbsp;: 2017&nbsp;: Technologies de l'information -- Langages de programmation -- C++</cite>, ISO, <time class="nowrap" datetime="2017-12" data-sort-value="2017-12">décembre 2017</time> <small style="line-height:1em;">(<a rel="nofollow" class="external text" href="https://www.iso.org/fr/standard/68564.html">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=ISO%2FIEC+14882+%3A+2017&amp;rft.pub=ISO&amp;rft.stitle=Technologies+de+l%27information+--+Langages+de+programmation+--+C%2B%2B&amp;rft.date=2017-12&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><a href="#cite_ref-6">↑</a> </span><span class="reference-text"><span class="ouvrage" id="14:00-17:00"><span class="nom_auteur">14:00-17:00</span>, «&nbsp;<a rel="nofollow" class="external text" href="https://www.iso.org/cms/render/live/fr/sites/isoorg/contents/data/standard/07/93/79358.html"><cite style="font-style:normal;">ISO/IEC 14882:2020</cite></a>&nbsp;», sur <span class="italique">ISO</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2020-12-20" data-sort-value="2020-12-20">20 décembre 2020</time>)</small></span></span>
</li>
<li id="cite_note-7"><span class="mw-cite-backlink"><a href="#cite_ref-7">↑</a> </span><span class="reference-text"><span class="ouvrage" id="Stroustrup"><span class="ouvrage" id="Bjarne_Stroustrup"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a>, «&nbsp;<a rel="nofollow" class="external text" href="https://www.stroustrup.com/bs_faq.html#name"><cite style="font-style:normal;" lang="en">Bjarne Stroustrup's FAQ</cite></a>&nbsp;» <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2024-09-05" data-sort-value="2024-09-05">5 septembre 2024</time>)</small></span></span></span>
</li>
<li id="cite_note-8"><span class="mw-cite-backlink"><a href="#cite_ref-8">↑</a> </span><span class="reference-text"><span class="ouvrage" id="Stroustrup2018"><span class="ouvrage" id="Bjarne_Stroustrup2018"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> Bjarne Stroustrup, <cite class="italique" lang="en">A Tour of C++</cite>, Addison-Wesley, <abbr class="abbr" title="collection">coll.</abbr>&nbsp;«&nbsp;C++ In-Depth Series&nbsp;», <time>2018</time>, 240&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-13-499783-4</span>)</small>, 16.1.1 Timeline<span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=A+Tour+of+C%2B%2B&amp;rft.pub=Addison-Wesley&amp;rft.aulast=Stroustrup&amp;rft.aufirst=Bjarne&amp;rft.date=2018&amp;rft.tpages=240&amp;rft.isbn=978-0-13-499783-4&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span></span>
</li>
<li id="cite_note-9"><span class="mw-cite-backlink"><a href="#cite_ref-9">↑</a> </span><span class="reference-text"><span class="ouvrage">«&nbsp;<a rel="nofollow" class="external text" href="http://www.web-libre.org/programmation-langage-cpp,1675.html"><cite style="font-style:normal;">Programmation Langage C++ - Web-Libre.org</cite></a>&nbsp;», sur <span class="italique">www.web-libre.org</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2020-10-06" data-sort-value="2020-10-06">6 octobre 2020</time>)</small></span></span>
</li>
<li id="cite_note-10"><span class="mw-cite-backlink"><a href="#cite_ref-10">↑</a> </span><span class="reference-text"><span class="ouvrage">«&nbsp;<a rel="nofollow" class="external text" href="https://isocpp.org/wiki/faq/references"><cite style="font-style:normal;">Standard C++</cite></a>&nbsp;», sur <span class="italique">isocpp.org</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2022-01-27" data-sort-value="2022-01-27">27 janvier 2022</time>)</small></span>&nbsp;: <span class="citation">«&nbsp;References are useful for several things, but the direct reason they were introduced in C++ was to support operator overloading&nbsp;»</span></span>
</li>
<li id="cite_note-11"><span class="mw-cite-backlink"><a href="#cite_ref-11">↑</a> </span><span class="reference-text"><span class="ouvrage" id="corob-msft"><abbr class="abbr indicateur-langue" title="Langue : anglais américain">(en-US)</abbr> <span class="nom_auteur">corob-msft</span>, «&nbsp;<a rel="nofollow" class="external text" href="https://docs.microsoft.com/en-us/cpp/cpp/welcome-back-to-cpp-modern-cpp"><cite style="font-style:normal;" lang="en-us">Welcome back to C++ - Modern C++</cite></a>&nbsp;», sur <span class="italique">docs.microsoft.com</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2020-12-21" data-sort-value="2020-12-21">21 décembre 2020</time>)</small></span></span>
</li>
<li id="cite_note-12"><span class="mw-cite-backlink"><a href="#cite_ref-12">↑</a> </span><span class="reference-text"><i><span class="lang-en" lang="en">The C++ Programming Language, Third Edition</span></i>, chap. 1.1.1, page 5</span>
</li>
<li id="cite_note-13"><span class="mw-cite-backlink"><a href="#cite_ref-13">↑</a> </span><span class="reference-text"><span class="ouvrage" id="Snyder,_Louis_Dionne2018"><span class="ouvrage" id="Jeff_Snyder,_Louis_Dionne2018"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> Jeff Snyder, Louis Dionne, «&nbsp;<a rel="nofollow" class="external text" href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0732r2.pdf"><cite style="font-style:normal;" lang="en">Class Types in Non-Type Template Parameters</cite></a>&nbsp;», <time class="nowrap" datetime="2018-06-06" data-sort-value="2018-06-06">6 juin 2018</time> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2021-03-12" data-sort-value="2021-03-12">12 mars 2021</time>)</small></span></span></span>
</li>
<li id="cite_note-14"><span class="mw-cite-backlink"><a href="#cite_ref-14">↑</a> </span><span class="reference-text"><span class="ouvrage">«&nbsp;<a rel="nofollow" class="external text" href="https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#index-fdevirtualize"><cite style="font-style:normal;">Using the GNU Compiler Collection (GCC): Optimize Options</cite></a>&nbsp;», sur <span class="italique">gcc.gnu.org</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2019-03-11" data-sort-value="2019-03-11">11 mars 2019</time>)</small></span></span>
</li>
<li id="cite_note-15"><span class="mw-cite-backlink"><a href="#cite_ref-15">↑</a> </span><span class="reference-text"><span class="ouvrage">«&nbsp;<a rel="nofollow" class="external text" href="https://www.jetbrains.com/lp/devecosystem-2023/cpp/#cpp_projectmodels_two_years"><cite style="font-style:normal;">The State of Developer Ecosystem 2023: Which project models or build systems do you regularly use? by JetBrains</cite></a>&nbsp;», sur <span class="italique">JetBrains</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2025-04-05" data-sort-value="2025-04-05">5 avril 2025</time>)</small></span>.</span>
</li>
<li id="cite_note-16"><span class="mw-cite-backlink"><a href="#cite_ref-16">↑</a> </span><span class="reference-text"><span class="ouvrage">«&nbsp;<a rel="nofollow" class="external text" href="https://www.jetbrains.com/clion/"><cite style="font-style:normal;">CLion&nbsp;: A Cross-Platform IDE for C and C++ by JetBrains</cite></a>&nbsp;», sur <span class="italique">JetBrains</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2020-08-04" data-sort-value="2020-08-04">4 août 2020</time>)</small></span>.</span>
</li>
<li id="cite_note-17"><span class="mw-cite-backlink"><a href="#cite_ref-17">↑</a> </span><span class="reference-text"><span class="ouvrage" id="Schaefer"><span class="ouvrage" id="Doug_Schaefer"><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> Doug <span class="nom_auteur">Schaefer</span>, «&nbsp;<a rel="nofollow" class="external text" href="http://www.eclipse.org/cdt/"><cite style="font-style:normal;" lang="en">Eclipse CDT | The Eclipse Foundation</cite></a>&nbsp;», sur <span class="italique">www.eclipse.org</span> <small style="line-height:1em;">(consulté le <time class="nowrap" datetime="2020-10-04" data-sort-value="2020-10-04">4 octobre 2020</time>)</small></span></span></span>
</li>
</ol></div>
</div>
<div class="mw-heading mw-heading2"><h2 id="Annexes">Annexes</h2></div>
<style data-mw-deduplicate="TemplateStyles:r194021218">
/* start https://fr.wikipedia.org/ */


.mw-parser-output .autres-projets>.titre{text-align:center;margin:0.2em 0}.mw-parser-output .autres-projets>ul{margin:0;padding:0}.mw-parser-output .autres-projets>ul>li{list-style:none;margin:0.2em 0;text-indent:0;padding-left:24px;min-height:20px;text-align:left;display:block}.mw-parser-output .autres-projets>ul>li>a{font-style:italic}@media(max-width:720px){.mw-parser-output .autres-projets{float:none}}


/* end https://fr.wikipedia.org/ */
</style>
<div class="mw-heading mw-heading3"><h3 id="Bibliographie">Bibliographie</h3></div>
<div class="mw-heading mw-heading4"><h4 id="Ouvrages_en_langue_anglaise">Ouvrages en langue anglaise</h4></div>
<ul><li><span class="ouvrage" id="DeitelDeitel2011"><span class="ouvrage" id="P._DeitelH._Deitel2011"><small>[Deitel et Deitel 2011]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> P. Deitel et H. Deitel, <cite class="italique" lang="en">C++&nbsp;: How to Program</cite>, 20 Hall, <time>2011</time>, <abbr class="abbr" title="huitième">8<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 1104&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-13-266236-9</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B&amp;rft.pub=20+Hall&amp;rft.edition=8&amp;rft.stitle=How+to+Program&amp;rft.aulast=Deitel&amp;rft.aufirst=P.&amp;rft.au=H.+Deitel&amp;rft.date=2011&amp;rft.tpages=1104&amp;rft.isbn=978-0-13-266236-9&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Dawson2010"><span class="ouvrage" id="M._Dawson2010"><small>[Dawson 2010]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> M. Dawson, <cite class="italique" lang="en">Beginning C++ Through Game Programming</cite>, Course Technology PTR, <time>2010</time>, <abbr class="abbr" title="troisième">3<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 432&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-1-4354-5742-3</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Beginning+C%2B%2B+Through+Game+Programming&amp;rft.pub=Course+Technology+PTR&amp;rft.edition=3&amp;rft.aulast=Dawson&amp;rft.aufirst=M.&amp;rft.date=2010&amp;rft.tpages=432&amp;rft.isbn=978-1-4354-5742-3&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Ouvrage pour débutants dont la pédagogie prend acte du fait que le C++ fait tourner la plupart des jeux vidéo en 2010.</div></li>
<li><span class="ouvrage" id="GregoireSolterKleper2011"><span class="ouvrage" id="Marc_GregoireNicolas_A._SolterScott_J._Kleper2011"><small>[Gregoire, Solter et Kleper 2011]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> Marc Gregoire, Nicolas A. Solter et Scott J. Kleper, <cite class="italique" lang="en">Professional C++</cite>, John Wiley, <time class="nowrap" datetime="2011-10" data-sort-value="2011-10">octobre 2011</time>, 1104&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-470-93244-5</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=ZBxxFqrrjyYC&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Professional+C%2B%2B&amp;rft.pub=John+Wiley&amp;rft.aulast=Gregoire&amp;rft.aufirst=Marc&amp;rft.au=Nicolas+A.+Solter&amp;rft.au=Scott+J.+Kleper&amp;rft.date=2011-10&amp;rft.tpages=1104&amp;rft.isbn=978-0-470-93244-5&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Cet ouvrage couvre la norme C++11.</div></li>
<li><span class="ouvrage" id="Josuttis2011"><span class="ouvrage" id="Nicolaï_Josuttis2011"><small>[Josuttis 2011]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> Nicolaï Josuttis, <cite class="italique" lang="en">The C++ Standard Library, A Tutorial and Reference</cite>, Addison-Wesley, <time>2011</time>, <abbr class="abbr" title="deuxième">2<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 1099&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-321-62321-8</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=gUhE8po4jgAC&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=The+C%2B%2B+Standard+Library%2C+A+Tutorial+and+Reference&amp;rft.pub=Addison-Wesley&amp;rft.edition=2&amp;rft.aulast=Josuttis&amp;rft.aufirst=Nicola%C3%AF&amp;rft.date=2011&amp;rft.tpages=1099&amp;rft.isbn=978-0-321-62321-8&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Cet ouvrage couvre la norme C++11.</div></li>
<li><span class="ouvrage" id="KoenigMoo2000"><span class="ouvrage" id="A._KoenigB._Moo2000"><small>[Koenig et Moo 2000]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> A. Koenig et B. Moo, <cite class="italique" lang="en">Accelerated C++&nbsp;: Practical Programming by Example</cite>, Addison-Wesley, <time>2000</time>, <abbr class="abbr" title="première">1<sup>re</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 352&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-201-70353-5</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Accelerated+C%2B%2B&amp;rft.pub=Addison-Wesley&amp;rft.edition=1&amp;rft.stitle=Practical+Programming+by+Example&amp;rft.aulast=Koenig&amp;rft.aufirst=A.&amp;rft.au=B.+Moo&amp;rft.date=2000&amp;rft.tpages=352&amp;rft.isbn=978-0-201-70353-5&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="LippmanLajoieMoo2012"><span class="ouvrage" id="Stanley_B._LippmanJosée_LajoieBarbara_E._Moo2012"><small>[Lippman, Lajoie et Moo 2012]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> Stanley B. Lippman, Josée Lajoie et Barbara E. Moo, <cite class="italique" lang="en">C++ Primer&nbsp;: 5th Edition</cite>, <time class="nowrap" datetime="2012-08" data-sort-value="2012-08">août 2012</time>, <abbr class="abbr" title="cinquième">5<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 1399&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-321-71411-4</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B+Primer&amp;rft.edition=5&amp;rft.stitle=5th+Edition&amp;rft.aulast=Lippman&amp;rft.aufirst=Stanley+B.&amp;rft.au=Jos%C3%A9e+Lajoie&amp;rft.au=Barbara+E.+Moo&amp;rft.date=2012-08&amp;rft.tpages=1399&amp;rft.isbn=978-0-321-71411-4&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Cet ouvrage couvre la norme C++11.</div></li>
<li><span class="ouvrage" id="Lischner2003"><span class="ouvrage" id="R._Lischner2003"><small>[Lischner 2003]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> R. Lischner, <cite class="italique" lang="en">C++ in a nutshell</cite>, O'Reilly Media, <time>2003</time>, <abbr class="abbr" title="première">1<sup>re</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 704&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-596-00298-5</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B+in+a+nutshell&amp;rft.pub=O%27Reilly+Media&amp;rft.edition=1&amp;rft.aulast=Lischner&amp;rft.aufirst=R.&amp;rft.date=2003&amp;rft.tpages=704&amp;rft.isbn=978-0-596-00298-5&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">L'auteur a aussi produit un petit manuel de référence sur la <a href="Standard_Template_Library" title="Standard Template Library">STL</a>, toujours aux éditions O'Reilly.</div></li>
<li><span class="ouvrage" id="Meyers2005"><span class="ouvrage" id="S._Meyers2005"><small>[Meyers 2005]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> S. Meyers, <cite class="italique" lang="en">Effective C++&nbsp;: 55 Specific Ways to Improve Your Programs and Designs</cite>, Addison-Wesley Professional, <time>2005</time>, <abbr class="abbr" title="troisième">3<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 320&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-321-33487-9</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=eQq9AQAAQBAJ&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Effective+C%2B%2B&amp;rft.pub=Addison-Wesley+Professional&amp;rft.edition=3&amp;rft.stitle=55+Specific+Ways+to+Improve+Your+Programs+and+Designs&amp;rft.aulast=Meyers&amp;rft.aufirst=S.&amp;rft.date=2005&amp;rft.tpages=320&amp;rft.isbn=978-0-321-33487-9&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Mêmes principes que les ouvrages de Sutter, et même public visé.</div></li>
<li><span class="ouvrage" id="Oualline2003"><span class="ouvrage" id="S._Oualline2003"><small>[Oualline 2003]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> S. Oualline, <cite class="italique" lang="en">Practical C++ programming</cite>, O'Reilly Media, <time>2003</time>, <abbr class="abbr" title="deuxième">2<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 600&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-596-00419-4</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=pXDzdJ_1E3oC&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Practical+C%2B%2B+programming&amp;rft.pub=O%27Reilly+Media&amp;rft.edition=2&amp;rft.aulast=Oualline&amp;rft.aufirst=S.&amp;rft.date=2003&amp;rft.tpages=600&amp;rft.isbn=978-0-596-00419-4&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Lafore2001"><span class="ouvrage" id="R._Lafore2001"><small>[Lafore 2001]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> R. Lafore, <cite class="italique" lang="en">Object-oriented programming in C++</cite>, Sams, <time>2001</time>, <abbr class="abbr" title="quatrième">4<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 1040&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-672-32308-9</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Object-oriented+programming+in+C%2B%2B&amp;rft.pub=Sams&amp;rft.edition=4&amp;rft.aulast=Lafore&amp;rft.aufirst=R.&amp;rft.date=2001&amp;rft.tpages=1040&amp;rft.isbn=978-0-672-32308-9&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Prata2011"><span class="ouvrage" id="S._Prata2011"><small>[Prata 2011]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> S. Prata, <cite class="italique" lang="en">C++ Primer Plus (Developer's Library)</cite>, Addison-Wesley Professional, <time>2011</time>, <abbr class="abbr" title="sixième">6<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 1200&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-321-77640-2</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=P7HuWSWtsh0C&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B+Primer+Plus+%28Developer%27s+Library%29&amp;rft.pub=Addison-Wesley+Professional&amp;rft.edition=6&amp;rft.aulast=Prata&amp;rft.aufirst=S.&amp;rft.date=2011&amp;rft.tpages=1200&amp;rft.isbn=978-0-321-77640-2&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Cette édition couvre les nouveautés apportées par le standard C++11.</div></li>
<li><span class="ouvrage" id="Stroustrup2009"><span class="ouvrage" id="Bjarne_Stroustrup2009"><small>[Stroustrup 2009]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a>, <cite class="italique" lang="en">Programming&nbsp;: Principles and Practice using C++</cite>, Addison-Wesley, <time>2009</time>, 1236&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-321-54372-1</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Programming&amp;rft.pub=Addison-Wesley&amp;rft.stitle=Principles+and+Practice+using+C%2B%2B&amp;rft.aulast=Stroustrup&amp;rft.aufirst=Bjarne&amp;rft.date=2009&amp;rft.tpages=1236&amp;rft.isbn=978-0-321-54372-1&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Stroustrup2013"><span class="ouvrage" id="Bjarne_Stroustrup2013"><small>[Stroustrup 2013]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a>, <cite class="italique" lang="en">The C++ Programming Language&nbsp;: 4th Edition</cite>, Addison-Wesley Professional, <time>2013</time>, <abbr class="abbr" title="quatrième">4<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 1368&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-321-56384-2</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=The+C%2B%2B+Programming+Language&amp;rft.pub=Addison-Wesley+Professional&amp;rft.edition=4&amp;rft.stitle=4th+Edition&amp;rft.aulast=Stroustrup&amp;rft.aufirst=Bjarne&amp;rft.date=2013&amp;rft.tpages=1368&amp;rft.isbn=978-0-321-56384-2&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Stroustrup1994"><span class="ouvrage" id="Bjarne_Stroustrup1994"><small>[Stroustrup 1994]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a>, <cite class="italique" lang="en">The Design and Evolution of C++</cite>, Addison-Wesley professional, <time>1994</time>, <abbr class="abbr" title="première">1<sup>re</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 480&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-201-54330-8</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=The+Design+and+Evolution+of+C%2B%2B&amp;rft.pub=Addison-Wesley+professional&amp;rft.edition=1&amp;rft.aulast=Stroustrup&amp;rft.aufirst=Bjarne&amp;rft.date=1994&amp;rft.tpages=480&amp;rft.isbn=978-0-201-54330-8&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Sutter1999"><span class="ouvrage" id="H._Sutter1999"><small>[Sutter 1999]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> H. Sutter, <cite class="italique" lang="en">Exceptional C++&nbsp;: 47 Engineering Puzzles, Programming Problems, and Solutions</cite>, Addison-Wesley Professional, <time>1999</time>, 240&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-201-61562-3</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=mT7E5gDuW_4C&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Exceptional+C%2B%2B&amp;rft.pub=Addison-Wesley+Professional&amp;rft.stitle=47+Engineering+Puzzles%2C+Programming+Problems%2C+and+Solutions&amp;rft.aulast=Sutter&amp;rft.aufirst=H.&amp;rft.date=1999&amp;rft.tpages=240&amp;rft.isbn=978-0-201-61562-3&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Publié aux éditions Eyrolles en 2000 sous le titre <i>Mieux programmer en C++ - 47 problèmes pratiques résolus</i>. Herb Sutter, spécialiste reconnu du C++, a produit deux suites à ce premier ouvrage, toujours basées sur des études de cas, à savoir&nbsp;: <i>More exceptional C++</i> (Addison-Wesley - 2001) et <i>Exceptional C++ style</i> (Addison-Wesley - 2004). Tous ces ouvrages concernent à priori des développeurs confirmés maîtrisant bien le langage C++.</div></li>
<li><span class="ouvrage" id="VandevoordeJosuttis2002"><span class="ouvrage" id="David_VandevoordeNicolaï_Josuttis2002"><small>[Vandevoorde et Josuttis 2002]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> David Vandevoorde et Nicolaï Josuttis, <cite class="italique" lang="en">C++ Templates&nbsp;: the Complete Guide</cite>, Addison-Weslay, <time>2002</time>, 528&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-201-73484-3</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B+Templates&amp;rft.pub=Addison-Weslay&amp;rft.stitle=the+Complete+Guide&amp;rft.aulast=Vandevoorde&amp;rft.aufirst=David&amp;rft.au=Nicola%C3%AF+Josuttis&amp;rft.date=2002&amp;rft.tpages=528&amp;rft.isbn=978-0-201-73484-3&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Vandevoorde1998"><span class="ouvrage" id="David_Vandevoorde1998"><small>[Vandevoorde 1998]</small> <abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> David Vandevoorde, <cite class="italique" lang="en">C++ Solutions&nbsp;: Companion to the C++ Programming Language</cite>, Addison-Wesley, <time>1998</time>, <abbr class="abbr" title="troisième">3<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 292&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-0-201-30965-2</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B+Solutions&amp;rft.pub=Addison-Wesley&amp;rft.edition=3&amp;rft.stitle=Companion+to+the+C%2B%2B+Programming+Language&amp;rft.aulast=Vandevoorde&amp;rft.aufirst=David&amp;rft.date=1998&amp;rft.tpages=292&amp;rft.isbn=978-0-201-30965-2&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Contient la correction de nombre des exercices de l'ouvrage de Stroustrup, <i>Le langage C++</i>.</div></li></ul>
<div class="mw-heading mw-heading4"><h4 id="Ouvrages_en_langue_française"><span id="Ouvrages_en_langue_fran.C3.A7aise"></span>Ouvrages en langue française</h4></div>
<ul><li><span class="ouvrage" id="BenharratVittupier2021"><span class="ouvrage" id="Mehdi_BenharratBenoît_Vittupier2021"><small>[Benharrats et Vittupier 2021]</small> Mehdi Benharrat et Benoît Vittupier, <cite class="italique">Le guide du C++ moderne&nbsp;: de débutant à développeur</cite>, D-Booker, <time>2021</time>, <abbr class="abbr" title="première">1<sup>re</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 708&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-8227-0881-4</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=X909EAAAQBAJ&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Le+guide+du+C%2B%2B+moderne&amp;rft.pub=D-Booker&amp;rft.edition=1&amp;rft.stitle=de+d%C3%A9butant+%C3%A0+d%C3%A9veloppeur&amp;rft.aulast=Benharrat&amp;rft.aufirst=Mehdi&amp;rft.au=Beno%C3%AEt+Vittupier&amp;rft.date=2021&amp;rft.tpages=708&amp;rft.isbn=978-2-8227-0881-4&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="ChappelierSeydoux2005"><span class="ouvrage" id="J-C._ChappelierF._Seydoux2005"><small>[Chappelier et Seydoux 2005]</small> J-C. Chappelier et F. Seydoux, <cite class="italique">C++ par la pratique&nbsp;: Recueil d'exercices corrigés et aide-mémoire</cite>, PPUR, <time>2005</time>, <abbr class="abbr" title="deuxième">2<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 412&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-88074-732-9</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=5N0ojz8wh4YC&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B+par+la+pratique&amp;rft.pub=PPUR&amp;rft.edition=2&amp;rft.stitle=Recueil+d%27exercices+corrig%C3%A9s+et+aide-m%C3%A9moire&amp;rft.aulast=Chappelier&amp;rft.aufirst=J-C.&amp;rft.au=F.+Seydoux&amp;rft.date=2005&amp;rft.tpages=412&amp;rft.isbn=978-2-88074-732-9&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="DeitelDeitel2004"><span class="ouvrage" id="P._DeitelH._Deitel2004"><small>[Deitel et Deitel 2004]</small> P. Deitel et H. Deitel, <cite class="italique">Comment programmer en C++</cite>, Reynald Goulet, <time>2004</time>, 1178&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-89377-290-5</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Comment+programmer+en+C%2B%2B&amp;rft.pub=Reynald+Goulet&amp;rft.aulast=Deitel&amp;rft.aufirst=P.&amp;rft.au=H.+Deitel&amp;rft.date=2004&amp;rft.tpages=1178&amp;rft.isbn=978-2-89377-290-5&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">La dernière traduction disponible de l'ouvrage des Deitel père et fils&nbsp;; correspond à la troisième édition en langue anglaise.</div></li>
<li><span class="ouvrage" id="Delannoy2011"><span class="ouvrage" id="Claude_Delannoy2011"><small>[Delannoy 2001]</small> Claude <span class="nom_auteur">Delannoy</span>, <cite class="italique">Programmer en langage C++</cite>, Paris, Eyrolles, <time>2011</time>, <abbr class="abbr" title="huitième">8<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 822&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-212-12976-2</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=j5YKqVNo_C8C&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Programmer+en+langage+C%2B%2B&amp;rft.place=Paris&amp;rft.pub=Eyrolles&amp;rft.edition=8&amp;rft.aulast=Delannoy&amp;rft.aufirst=Claude&amp;rft.date=2011&amp;rft.tpages=822&amp;rft.isbn=978-2-212-12976-2&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Delannoy2007"><span class="ouvrage" id="Claude_Delannoy2007"><small>[Delannoy 2007]</small> Claude <span class="nom_auteur">Delannoy</span>, <cite class="italique">Exercices en langage C++</cite>, Paris, Eyrolles, <time>2007</time>, <abbr class="abbr" title="troisième">3<sup>e</sup></abbr>&nbsp;<abbr class="abbr" title="édition">éd.</abbr>, 336&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-212-12201-5</span>, <a rel="nofollow" class="external text" href="https://books.google.com/books?id=Wbdk1cHcAM8C&amp;printsec=frontcover">présentation en ligne</a>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Exercices+en+langage+C%2B%2B&amp;rft.place=Paris&amp;rft.pub=Eyrolles&amp;rft.edition=3&amp;rft.aulast=Delannoy&amp;rft.aufirst=Claude&amp;rft.date=2007&amp;rft.tpages=336&amp;rft.isbn=978-2-212-12201-5&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="GéronTawbi2003"><span class="ouvrage" id="Aurélien_GéronFatmé_Tawbi2003"><small>[Géron et Tawbi 2003]</small> Aurélien <span class="nom_auteur">Géron</span> et Fatmé Tawbi (<abbr class="abbr" title="préface">préf.</abbr>&nbsp;Gilles Clavel), <cite class="italique">Pour mieux développer avec C++&nbsp;: Design patterns, STL, RTTI et smart pointers</cite>, Paris, Dunod, <time>2003</time>, 188&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-10-007348-1</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Pour+mieux+d%C3%A9velopper+avec+C%2B%2B&amp;rft.place=Paris&amp;rft.pub=Dunod&amp;rft.stitle=Design+patterns%2C+STL%2C+RTTI+et+smart+pointers&amp;rft.aulast=G%C3%A9ron&amp;rft.aufirst=Aur%C3%A9lien&amp;rft.au=Fatm%C3%A9+Tawbi&amp;rft.date=2003&amp;rft.tpages=188&amp;rft.isbn=978-2-10-007348-1&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Guidet2008"><span class="ouvrage" id="Alexandre_Guidet2008"><small>[Guidet 2008]</small> Alexandre <span class="nom_auteur">Guidet</span>, <cite class="italique">Programmation objet en langage C++</cite>, Paris, Ellipses, <abbr class="abbr" title="collection">coll.</abbr>&nbsp;«&nbsp;Cours et exercices.&nbsp;», <time>2008</time>, 364&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-7298-3693-1</span>, <a href="Online_Computer_Library_Center" title="Online Computer Library Center">OCLC</a>&nbsp;<span class=" noarchive nowrap"><a rel="nofollow" class="external text" href="https://worldcat.org/fr/title/221607125">221607125</a></span>, <a href="Biblioth%C3%A8que_nationale_de_France" title="Bibliothèque nationale de France">BNF</a>&nbsp;<span class=" noarchive nowrap"><a rel="nofollow" class="external text" href="https://catalogue.bnf.fr/ark:/12148/cb412064266.public">41206426</a></span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Programmation+objet+en+langage+C%2B%2B&amp;rft.place=Paris&amp;rft.pub=Ellipses&amp;rft.aulast=Guidet&amp;rft.aufirst=Alexandre&amp;rft.date=2008&amp;rft.tpages=364&amp;rft.isbn=978-2-7298-3693-1&amp;rft_id=info%3Aoclcnum%2F221607125&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Hubbard2002"><span class="ouvrage" id="J._R._Hubbard2002"><small>[Hubbard 2002]</small> J. R. <span class="nom_auteur">Hubbard</span> (<abbr class="abbr" title="traduction">trad.</abbr>&nbsp;Virginie Maréchal), <cite class="italique">C++</cite> [«&nbsp;Schaum's easy outline of programming with C++&nbsp;»], Paris, EdiScience, <abbr class="abbr" title="collection">coll.</abbr>&nbsp;«&nbsp;Mini Schaum's&nbsp;», <time>2002</time>, 192&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-10-006510-3</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B&amp;rft.place=Paris&amp;rft.pub=EdiScience&amp;rft.aulast=Hubbard&amp;rft.aufirst=J.+R.&amp;rft.date=2002&amp;rft.tpages=192&amp;rft.isbn=978-2-10-006510-3&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.<div style="margin-left:2em; line-height:1.5;">Pour débutants pressés.</div></li>
<li><span class="ouvrage" id="LibertyJones2005"><span class="ouvrage" id="Jesse_LibertyBradley_Jones2005"><small>[Liberty et Jones 2005]</small> Jesse <span class="nom_auteur">Liberty</span> et Bradley Jones (<abbr class="abbr" title="traduction">trad.</abbr>&nbsp;Nathalie Le Guillou de Penanros), <cite class="italique">Le langage C++</cite> [«&nbsp;Teach yourself C++ in 21 days&nbsp;»], Paris, CampusPress, <time>2005</time>, 859&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-7440-1928-9</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Le+langage+C%2B%2B&amp;rft.place=Paris&amp;rft.pub=CampusPress&amp;rft.aulast=Liberty&amp;rft.aufirst=Jesse&amp;rft.au=Bradley+Jones&amp;rft.date=2005&amp;rft.tpages=859&amp;rft.isbn=978-2-7440-1928-9&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="StephensDigginsTurkanisCogswell2006"><span class="ouvrage" id="D._Ryan_StephensChristopher_DigginsJonathan_TurkanisJ._Cogswell2006"><small>[Stephens, Diggins, Turkanis <i><abbr class="abbr" title="et alii (« et d’autres »)" lang="la">et al.</abbr></i> 2006]</small> D. Ryan <span class="nom_auteur">Stephens</span>, Christopher Diggins, Jonathan Turkanis et J. Cogswell (<abbr class="abbr" title="traduction">trad.</abbr>&nbsp;Yves Baily &amp; Dalil Djidel), <cite class="italique">C++ en action</cite> [«&nbsp;C++ Cookbook - Solutions and Examples for C++ Programmers&nbsp;»], Paris, O'Reilly, <time>2006</time>, 555&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-84177-407-4</span>, <a href="Online_Computer_Library_Center" title="Online Computer Library Center">OCLC</a>&nbsp;<span class=" noarchive nowrap"><a rel="nofollow" class="external text" href="https://worldcat.org/fr/title/717532188">717532188</a></span>, <a href="Biblioth%C3%A8que_nationale_de_France" title="Bibliothèque nationale de France">BNF</a>&nbsp;<span class=" noarchive nowrap"><a rel="nofollow" class="external text" href="https://catalogue.bnf.fr/ark:/12148/cb40170870g.public">40170870</a></span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=C%2B%2B+en+action&amp;rft.place=Paris&amp;rft.pub=O%27Reilly&amp;rft.aulast=Stephens&amp;rft.aufirst=D.+Ryan&amp;rft.au=Christopher+Diggins&amp;rft.au=Jonathan+Turkanis&amp;rft.au=J.+Cogswell&amp;rft.date=2006&amp;rft.tpages=555&amp;rft.isbn=978-2-84177-407-4&amp;rft_id=info%3Aoclcnum%2F717532188&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Stroustrup2012"><span class="ouvrage" id="Bjarne_Stroustrup2012"><small>[Stroustrup 2012]</small> <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a> (<abbr class="abbr" title="traduction">trad.</abbr>&nbsp;Marie-Cécile Baland, Emmanuelle Burr, Christine Eberhardt), <cite class="italique">Programmation&nbsp;: principes et pratique avec C++&nbsp;: Avec plus de 1000 exercices.</cite> [«&nbsp;Programming&nbsp;: principles and practice using C++&nbsp;»], Paris, Pearson education, <time>2012</time>, 944&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-7440-7718-0</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Programmation+%3A+principes+et+pratique+avec+C%2B%2B&amp;rft.place=Paris&amp;rft.pub=Pearson+education&amp;rft.stitle=Avec+plus+de+1000+exercices.&amp;rft.aulast=Stroustrup&amp;rft.aufirst=Bjarne&amp;rft.date=2012&amp;rft.tpages=944&amp;rft.isbn=978-2-7440-7718-0&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="Stroustrup2003"><span class="ouvrage" id="Bjarne_Stroustrup2003"><small>[Stroustrup 2003]</small> <a href="Bjarne_Stroustrup" title="Bjarne Stroustrup">Bjarne Stroustrup</a> (<abbr class="abbr" title="traduction">trad.</abbr>&nbsp;Christine Eberhardt), <cite class="italique">Le langage C++</cite> [«&nbsp;The C++ programming language&nbsp;»], Paris, Pearson education, <time>2003</time>, 1098&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-7440-7003-7</span> et <span class="nowrap">2-744-07003-3</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Le+langage+C%2B%2B&amp;rft.place=Paris&amp;rft.pub=Pearson+education&amp;rft.aulast=Stroustrup&amp;rft.aufirst=Bjarne&amp;rft.date=2003&amp;rft.tpages=1098&amp;rft.isbn=978-2-7440-7003-7&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li>
<li><span class="ouvrage" id="SutterAlexandrescu2005"><span class="ouvrage" id="Herb_SutterAndrei_Alexandrescu2005"><small>[Sutter et Alexandrescu 2005]</small> Herb <span class="nom_auteur">Sutter</span> et Andrei Alexandrescu, <cite class="italique">Standards de programmation C</cite> [«&nbsp;C++ Coding Standards: 101 Rules, Guidelines, and Best Practices&nbsp;»], Paris, Pearson Education France, <abbr class="abbr" title="collection">coll.</abbr>&nbsp;«&nbsp;C++&nbsp;», <time>2005</time>, 243&nbsp;<abbr class="abbr" title="pages">p.</abbr> <small style="line-height:1em;">(<a href="International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&nbsp;<span class="nowrap">978-2-7440-7144-7</span> et <span class="nowrap">2-744-07144-7</span>)</small><span class="Z3988" title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Standards+de+programmation+C&amp;rft.place=Paris&amp;rft.pub=Pearson+Education+France&amp;rft.aulast=Sutter&amp;rft.aufirst=Herb&amp;rft.au=Andrei+Alexandrescu&amp;rft.date=2005&amp;rft.tpages=243&amp;rft.isbn=978-2-7440-7144-7&amp;rfr_id=info%3Asid%2Ffr.wikipedia.org%3AC%2B%2B"></span></span></span>.</li></ul>
<div class="mw-heading mw-heading3"><h3 id="Articles_connexes">Articles connexes</h3></div>
<ul><li><a href="C_(langage)" title="C (langage)">Langage C</a></li></ul>
<div class="mw-heading mw-heading3"><h3 id="Liens_externes">Liens externes</h3></div>
<ul><li><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a rel="nofollow" class="external text" href="http://www.open-std.org/jtc1/sc22/wg21/">Le Comité du Standard C++</a></li>
<li><abbr class="abbr indicateur-langue" title="Langue : français">(fr)</abbr> <a rel="nofollow" class="external text" href="https://fr.cppreference.com/w/">Documentation du C++</a> (wiki sous double licence <a href="CC-BY-SA" class="mw-redirect" title="CC-BY-SA">CC-BY-SA</a> et <a href="GFDL" class="mw-redirect" title="GFDL">GFDL</a>)</li>
<li><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a rel="nofollow" class="external text" href="http://en.cppreference.com/w/">Documentation du C++</a> (le même wiki mais en anglais et plus complet)</li>
<li><abbr class="abbr indicateur-langue" title="Langue : anglais">(en)</abbr> <a rel="nofollow" class="external text" href="http://www.cplusplus.com/">Documentation du C++</a> (contenu non libre, édité par <i>The C++ ressources network</i>)</li></ul>
<div class="navbox-container" style="clear:both;">



</div>
<ul id="bandeau-portail" class="bandeau-portail"><li><span class="bandeau-portail-element"><span class="bandeau-portail-icone"><span class="noviewer" typeof="mw:File"></span></span> <span class="bandeau-portail-texte">Portail de la programmation informatique</span> </span></li> <li><span class="bandeau-portail-element"><span class="bandeau-portail-icone"><span class="noviewer" typeof="mw:File"></span></span> <span class="bandeau-portail-texte">Portail de l’informatique</span> </span></li> </ul></div><!--htdig_noindex--><div><div class="zim-footer">
Cet article est issu de <a class="external text" title="Dernière modification le 2025-10-18" href="https://fr.wikipedia.org/wiki/?title=C%2B%2B&amp;oldid=229858348">Wikipédia</a>. Sauf mention contraire, le texte est disponible sous <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.fr">Creative Commons Attribution-Share Alike 4.0</a>. Des conditions supplémentaires peuvent s’appliquer aux fichiers multimédias.
</div>
</div><!--/htdig_noindex--></div>
</div>
</main>
</div>
</div>
</div>
<script src="./_webp_/webpHandler.js"></script>

</body></html>